एकता में इन्वेंटरी और आइटम क्राफ्टिंग सिस्टम बनाना

इस ट्यूटोरियल में, मैं दिखाऊंगा कि Unity में Minecraft-style इन्वेंट्री और आइटम क्राफ्टिंग सिस्टम कैसे बनाया जाए।

वीडियो गेम में आइटम क्राफ्टिंग विशिष्ट (आमतौर पर सरल) वस्तुओं को नए और उन्नत गुणों के साथ अधिक जटिल वस्तुओं में संयोजित करने की एक प्रक्रिया है। उदाहरण के लिए, लकड़ी और पत्थर को मिलाकर कुदाल बनाना, या धातु की चादर और लकड़ी को मिलाकर तलवार बनाना।

नीचे दी गई क्राफ्टिंग प्रणाली मोबाइल-अनुकूल है और पूरी तरह से स्वचालित है, जिसका अर्थ है कि यह किसी भी UI लेआउट और कस्टम क्राफ्टिंग रेसिपी बनाने की क्षमता के साथ काम करेगी।

Sharp Coder वीडियो प्लेयर

चरण 1: क्राफ्टिंग यूआई सेट करें

हम क्राफ्टिंग यूआई स्थापित करके शुरू करते हैं:

  • एक नया कैनवास बनाएं (Unity शीर्ष टास्कबार: गेमऑब्जेक्ट -> यूआई -> कैनवास)
  • कैनवास ऑब्जेक्ट -> यूआई -> इमेज पर राइट-क्लिक करके एक नई छवि बनाएं
  • इमेज ऑब्जेक्ट का नाम बदलकर "CraftingPanel" करें और इसकी सोर्स इमेज को डिफ़ॉल्ट में बदलें "UISprite"
  • "CraftingPanel" रेक्टट्रांसफॉर्म मान को (स्थिति X: 0 स्थिति Y: 0 चौड़ाई: 410 ऊंचाई: 365) में बदलें

  • "CraftingPanel" के अंदर दो ऑब्जेक्ट बनाएं (क्राफ्टिंगपैनल पर राइट-क्लिक करें -> खाली बनाएं, 2 बार)
  • पहले ऑब्जेक्ट का नाम बदलकर "CraftingSlots" करें और इसके रेक्टट्रांसफॉर्म मानों को ("शीर्ष बाएँ संरेखित करें" पिवोट X: 0 पिवोट Y: 1 स्थिति X: 50 स्थिति Y: -35 चौड़ाई: 140 ऊंचाई: 140) में बदलें। इस ऑब्जेक्ट में क्राफ्टिंग स्लॉट होंगे।
  • दूसरे ऑब्जेक्ट का नाम बदलकर "PlayerSlots" करें और इसके रेक्टट्रांसफॉर्म मानों को बदलें ("टॉप स्ट्रेच हॉरिजॉन्टली" पिवोट एक्स: 0.5 पिवोट वाई: 1 लेफ्ट: 0 पॉज़ वाई: -222 राइट: 0 ऊंचाई: 100)। इस ऑब्जेक्ट में प्लेयर स्लॉट होंगे।

अनुभाग शीर्षक:

  • "PlayerSlots" ऑब्जेक्ट -> यूआई -> टेक्स्ट पर राइट-क्लिक करके नया टेक्स्ट बनाएं और उसका नाम बदलें "SectionTitle"
  • "SectionTitle" रेक्टट्रांसफॉर्म मानों को बदलें ("शीर्ष बाएँ संरेखित करें" धुरी X: 0 धुरी Y: 0 स्थिति X: 5 स्थिति Y: 0 चौड़ाई: 160 ऊंचाई: 30)
  • "SectionTitle" टेक्स्ट को "Inventory" में बदलें और इसका फ़ॉन्ट आकार 18, संरेखण को बाएं मध्य और रंग को (0.2, 0.2, 0.2, 1) पर सेट करें।
  • "SectionTitle" ऑब्जेक्ट को डुप्लिकेट करें, इसके टेक्स्ट को "Crafting" में बदलें और इसे "CraftingSlots" ऑब्जेक्ट के नीचे ले जाएं, फिर पिछले "SectionTitle" के समान RectTransform मान सेट करें।

क्राफ्टिंग स्लॉट:

क्राफ्टिंग स्लॉट में एक पृष्ठभूमि छवि, एक आइटम छवि और एक गिनती पाठ शामिल होगा:

  • कैनवास ऑब्जेक्ट -> यूआई -> इमेज पर राइट-क्लिक करके एक नई छवि बनाएं
  • नई छवि का नाम बदलकर "slot_template" करें, इसके रेक्टट्रांसफॉर्म मान को (पोस्ट
  • "slot_template" को डुप्लिकेट करें और इसका नाम बदलकर "Item" करें, इसे "slot_template" ऑब्जेक्ट के अंदर ले जाएं, इसके रेक्टट्रांसफॉर्म आयाम को (चौड़ाई: 30 ऊंचाई: 30) और रंग को (1, 1, 1, 1) में बदलें।
  • "slot_template" ऑब्जेक्ट -> यूआई -> टेक्स्ट पर राइट-क्लिक करके नया टेक्स्ट बनाएं और उसका नाम बदलें "Count"
  • "Count" रेक्टट्रांसफॉर्म मानों को बदलें ("नीचे दाएं संरेखित करें" धुरी X: 1 धुरी Y: 0 स्थिति X: 0 स्थिति Y: 0 चौड़ाई: 30 ऊंचाई: 30)
  • "Count" टेक्स्ट को एक यादृच्छिक संख्या (उदा. 12), फ़ॉन्ट शैली को बोल्ड, फ़ॉन्ट आकार 14, संरेखण को दाईं ओर और रंग को (1, 1, 1, 1) पर सेट करें।
  • "Count" टेक्स्ट में छाया घटक जोड़ें और प्रभाव रंग को (0, 0, 0, 0.5) पर सेट करें

अंतिम परिणाम इस तरह दिखना चाहिए:

परिणाम स्लॉट (इसका उपयोग परिणाम तैयार करने के लिए किया जाएगा):

  • "slot_template" ऑब्जेक्ट को डुप्लिकेट करें और उसका नाम बदलें "result_slot_template"
  • "result_slot_template" की चौड़ाई और ऊंचाई को 50 में बदलें

क्राफ्टिंग बटन और अतिरिक्त ग्राफ़िक्स:

  • "CraftingSlots" ऑब्जेक्ट -> यूआई -> बटन पर राइट-क्लिक करके एक नया बटन बनाएं और इसका नाम बदलें "CraftButton"
  • "CraftButton" रेक्टट्रांसफॉर्म मान को ("मध्य बाएँ संरेखित करें" पिवोट X: 1 पिवोट Y: 0.5 स्थिति X: 0 स्थिति Y: 0 चौड़ाई: 40 ऊंचाई: 40) पर सेट करें
  • "CraftButton" का टेक्स्ट बदलें "Craft"

  • "CraftingSlots" ऑब्जेक्ट -> यूआई -> इमेज पर राइट-क्लिक करके एक नई छवि बनाएं और इसका नाम बदलें "Arrow"
  • "Arrow" रेक्टट्रांसफॉर्म मान को ("मध्य दाएं संरेखित करें" पिवोट X: 0 पिवोट Y: 0.5 स्थिति X: 10 स्थिति Y: 0 चौड़ाई: 30 ऊंचाई: 30) पर सेट करें

स्रोत छवि के लिए, आप नीचे दी गई छवि का उपयोग कर सकते हैं (इसे डाउनलोड करने के लिए राइट-क्लिक करें -> इस रूप में सहेजें...)। आयात करने के बाद इसका टेक्सचर प्रकार "Sprite (2D and UI)" और फ़िल्टर मोड पर सेट करें "Point (no filter)"

तीर दायाँ चिह्न पिक्सेल

  • "CraftingSlots" पर राइट क्लिक करें -> खाली बनाएं और इसका नाम बदलकर "ResultSlot" कर दें, इस ऑब्जेक्ट में परिणाम स्लॉट होगा
  • "ResultSlot" रेक्टट्रांसफॉर्म मान को ("मध्य दाएं संरेखित करें" पिवोट X: 0 पिवोट Y: 0.5 स्थिति X: 50 स्थिति Y: 0 चौड़ाई: 50 ऊंचाई: 50) पर सेट करें

यूआई सेटअप तैयार है.

चरण 2: प्रोग्राम क्राफ्टिंग सिस्टम

इस क्राफ्टिंग सिस्टम में 2 स्क्रिप्ट शामिल होंगी, SC_ItemCrafting.cs, और SC_SlotTemplate.cs

  • एक नई स्क्रिप्ट बनाएं, इसे नाम दें "SC_ItemCrafting" फिर इसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_आइटमक्राफ्टिंग.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class SC_ItemCrafting : MonoBehaviour
{
    public RectTransform playerSlotsContainer;
    public RectTransform craftingSlotsContainer;
    public RectTransform resultSlotContainer;
    public Button craftButton;
    public SC_SlotTemplate slotTemplate;
    public SC_SlotTemplate resultSlotTemplate;

    [System.Serializable]
    public class SlotContainer
    {
        public Sprite itemSprite; //Sprite of the assigned item (Must be the same sprite as in items array), or leave null for no item
        public int itemCount; //How many items in this slot, everything equal or under 1 will be interpreted as 1 item
        [HideInInspector]
        public int tableID;
        [HideInInspector]
        public SC_SlotTemplate slot;
    }

    [System.Serializable]
    public class Item
    {
        public Sprite itemSprite;
        public bool stackable = false; //Can this item be combined (stacked) together?
        public string craftRecipe; //Item Keys that are required to craft this item, separated by comma (Tip: Use Craft Button in Play mode and see console for printed recipe)
    }

    public SlotContainer[] playerSlots;
    SlotContainer[] craftSlots = new SlotContainer[9];
    SlotContainer resultSlot = new SlotContainer();
    //List of all available items
    public Item[] items;

    SlotContainer selectedItemSlot = null;

    int craftTableID = -1; //ID of table where items will be placed one at a time (ex. Craft table)
    int resultTableID = -1; //ID of table from where we can take items, but cannot place to

    ColorBlock defaultButtonColors;

    // Start is called before the first frame update
    void Start()
    {
        //Setup slot element template
        slotTemplate.container.rectTransform.pivot = new Vector2(0, 1);
        slotTemplate.container.rectTransform.anchorMax = slotTemplate.container.rectTransform.anchorMin = new Vector2(0, 1);
        slotTemplate.craftingController = this;
        slotTemplate.gameObject.SetActive(false);
        //Setup result slot element template
        resultSlotTemplate.container.rectTransform.pivot = new Vector2(0, 1);
        resultSlotTemplate.container.rectTransform.anchorMax = resultSlotTemplate.container.rectTransform.anchorMin = new Vector2(0, 1);
        resultSlotTemplate.craftingController = this;
        resultSlotTemplate.gameObject.SetActive(false);

        //Attach click event to craft button
        craftButton.onClick.AddListener(PerformCrafting);
        //Save craft button default colors
        defaultButtonColors = craftButton.colors;

        //InitializeItem Crafting Slots
        InitializeSlotTable(craftingSlotsContainer, slotTemplate, craftSlots, 5, 0);
        UpdateItems(craftSlots);
        craftTableID = 0;

        //InitializeItem Player Slots
        InitializeSlotTable(playerSlotsContainer, slotTemplate, playerSlots, 5, 1);
        UpdateItems(playerSlots);

        //InitializeItemResult Slot
        InitializeSlotTable(resultSlotContainer, resultSlotTemplate, new SlotContainer[] { resultSlot }, 0, 2);
        UpdateItems(new SlotContainer[] { resultSlot });
        resultTableID = 2;

        //Reset Slot element template (To be used later for hovering element)
        slotTemplate.container.rectTransform.pivot = new Vector2(0.5f, 0.5f);
        slotTemplate.container.raycastTarget = slotTemplate.item.raycastTarget = slotTemplate.count.raycastTarget = false;
    }

    void InitializeSlotTable(RectTransform container, SC_SlotTemplate slotTemplateTmp, SlotContainer[] slots, int margin, int tableIDTmp)
    {
        int resetIndex = 0;
        int rowTmp = 0;
        for (int i = 0; i < slots.Length; i++)
        {
            if (slots[i] == null)
            {
                slots[i] = new SlotContainer();
            }
            GameObject newSlot = Instantiate(slotTemplateTmp.gameObject, container.transform);
            slots[i].slot = newSlot.GetComponent<SC_SlotTemplate>();
            slots[i].slot.gameObject.SetActive(true);
            slots[i].tableID = tableIDTmp;

            float xTmp = (int)((margin + slots[i].slot.container.rectTransform.sizeDelta.x) * (i - resetIndex));
            if (xTmp + slots[i].slot.container.rectTransform.sizeDelta.x + margin > container.rect.width)
            {
                resetIndex = i;
                rowTmp++;
                xTmp = 0;
            }
            slots[i].slot.container.rectTransform.anchoredPosition = new Vector2(margin + xTmp, -margin - ((margin + slots[i].slot.container.rectTransform.sizeDelta.y) * rowTmp));
        }
    }

    //Update Table UI
    void UpdateItems(SlotContainer[] slots)
    {
        for (int i = 0; i < slots.Length; i++)
        {
            Item slotItem = FindItem(slots[i].itemSprite);
            if (slotItem != null)
            {
                if (!slotItem.stackable)
                {
                    slots[i].itemCount = 1;
                }
                //Apply total item count
                if (slots[i].itemCount > 1)
                {
                    slots[i].slot.count.enabled = true;
                    slots[i].slot.count.text = slots[i].itemCount.ToString();
                }
                else
                {
                    slots[i].slot.count.enabled = false;
                }
                //Apply item icon
                slots[i].slot.item.enabled = true;
                slots[i].slot.item.sprite = slotItem.itemSprite;
            }
            else
            {
                slots[i].slot.count.enabled = false;
                slots[i].slot.item.enabled = false;
            }
        }
    }

    //Find Item from the items list using sprite as reference
    Item FindItem(Sprite sprite)
    {
        if (!sprite)
            return null;

        for (int i = 0; i < items.Length; i++)
        {
            if (items[i].itemSprite == sprite)
            {
                return items[i];
            }
        }

        return null;
    }

    //Find Item from the items list using recipe as reference
    Item FindItem(string recipe)
    {
        if (recipe == "")
            return null;

        for (int i = 0; i < items.Length; i++)
        {
            if (items[i].craftRecipe == recipe)
            {
                return items[i];
            }
        }

        return null;
    }

    //Called from SC_SlotTemplate.cs
    public void ClickEventRecheck()
    {
        if (selectedItemSlot == null)
        {
            //Get clicked slot
            selectedItemSlot = GetClickedSlot();
            if (selectedItemSlot != null)
            {
                if (selectedItemSlot.itemSprite != null)
                {
                    selectedItemSlot.slot.count.color = selectedItemSlot.slot.item.color = new Color(1, 1, 1, 0.5f);
                }
                else
                {
                    selectedItemSlot = null;
                }
            }
        }
        else
        {
            SlotContainer newClickedSlot = GetClickedSlot();
            if (newClickedSlot != null)
            {
                bool swapPositions = false;
                bool releaseClick = true;

                if (newClickedSlot != selectedItemSlot)
                {
                    //We clicked on the same table but different slots
                    if (newClickedSlot.tableID == selectedItemSlot.tableID)
                    {
                        //Check if new clicked item is the same, then stack, if not, swap (Unless it's a crafting table, then do nothing)
                        if (newClickedSlot.itemSprite == selectedItemSlot.itemSprite)
                        {
                            Item slotItem = FindItem(selectedItemSlot.itemSprite);
                            if (slotItem.stackable)
                            {
                                //Item is the same and is stackable, remove item from previous position and add its count to a new position
                                selectedItemSlot.itemSprite = null;
                                newClickedSlot.itemCount += selectedItemSlot.itemCount;
                                selectedItemSlot.itemCount = 0;
                            }
                            else
                            {
                                swapPositions = true;
                            }
                        }
                        else
                        {
                            swapPositions = true;
                        }
                    }
                    else
                    {
                        //Moving to different table
                        if (resultTableID != newClickedSlot.tableID)
                        {
                            if (craftTableID != newClickedSlot.tableID)
                            {
                                if (newClickedSlot.itemSprite == selectedItemSlot.itemSprite)
                                {
                                    Item slotItem = FindItem(selectedItemSlot.itemSprite);
                                    if (slotItem.stackable)
                                    {
                                        //Item is the same and is stackable, remove item from previous position and add its count to a new position
                                        selectedItemSlot.itemSprite = null;
                                        newClickedSlot.itemCount += selectedItemSlot.itemCount;
                                        selectedItemSlot.itemCount = 0;
                                    }
                                    else
                                    {
                                        swapPositions = true;
                                    }
                                }
                                else
                                {
                                    swapPositions = true;
                                }
                            }
                            else
                            {
                                if (newClickedSlot.itemSprite == null || newClickedSlot.itemSprite == selectedItemSlot.itemSprite)
                                {
                                    //Add 1 item from selectedItemSlot
                                    newClickedSlot.itemSprite = selectedItemSlot.itemSprite;
                                    newClickedSlot.itemCount++;
                                    selectedItemSlot.itemCount--;
                                    if (selectedItemSlot.itemCount <= 0)
                                    {
                                        //We placed the last item
                                        selectedItemSlot.itemSprite = null;
                                    }
                                    else
                                    {
                                        releaseClick = false;
                                    }
                                }
                                else
                                {
                                    swapPositions = true;
                                }
                            }
                        }
                    }
                }

                if (swapPositions)
                {
                    //Swap items
                    Sprite previousItemSprite = selectedItemSlot.itemSprite;
                    int previousItemConunt = selectedItemSlot.itemCount;

                    selectedItemSlot.itemSprite = newClickedSlot.itemSprite;
                    selectedItemSlot.itemCount = newClickedSlot.itemCount;

                    newClickedSlot.itemSprite = previousItemSprite;
                    newClickedSlot.itemCount = previousItemConunt;
                }

                if (releaseClick)
                {
                    //Release click
                    selectedItemSlot.slot.count.color = selectedItemSlot.slot.item.color = Color.white;
                    selectedItemSlot = null;
                }

                //Update UI
                UpdateItems(playerSlots);
                UpdateItems(craftSlots);
                UpdateItems(new SlotContainer[] { resultSlot });
            }
        }
    }

    SlotContainer GetClickedSlot()
    {
        for (int i = 0; i < playerSlots.Length; i++)
        {
            if (playerSlots[i].slot.hasClicked)
            {
                playerSlots[i].slot.hasClicked = false;
                return playerSlots[i];
            }
        }

        for (int i = 0; i < craftSlots.Length; i++)
        {
            if (craftSlots[i].slot.hasClicked)
            {
                craftSlots[i].slot.hasClicked = false;
                return craftSlots[i];
            }
        }

        if (resultSlot.slot.hasClicked)
        {
            resultSlot.slot.hasClicked = false;
            return resultSlot;
        }

        return null;
    }

    void PerformCrafting()
    {
        string[] combinedItemRecipe = new string[craftSlots.Length];

        craftButton.colors = defaultButtonColors;

        for (int i = 0; i < craftSlots.Length; i++)
        {
            Item slotItem = FindItem(craftSlots[i].itemSprite);
            if (slotItem != null)
            {
                combinedItemRecipe[i] = slotItem.itemSprite.name + (craftSlots[i].itemCount > 1 ? "(" + craftSlots[i].itemCount + ")" : "");
            }
            else
            {
                combinedItemRecipe[i] = "";
            }
        }

        string combinedRecipe = string.Join(",", combinedItemRecipe);
        print(combinedRecipe);

        //Search if recipe match any of the item recipe
        Item craftedItem = FindItem(combinedRecipe);
        if (craftedItem != null)
        {
            //Clear Craft slots
            for (int i = 0; i < craftSlots.Length; i++)
            {
                craftSlots[i].itemSprite = null;
                craftSlots[i].itemCount = 0;
            }

            resultSlot.itemSprite = craftedItem.itemSprite;
            resultSlot.itemCount = 1;

            UpdateItems(craftSlots);
            UpdateItems(new SlotContainer[] { resultSlot });
        }
        else
        {
            ColorBlock colors = craftButton.colors;
            colors.selectedColor = colors.pressedColor = new Color(0.8f, 0.55f, 0.55f, 1);
            craftButton.colors = colors;
        }
    }

    // Update is called once per frame
    void Update()
    {
        //Slot UI follow mouse position
        if (selectedItemSlot != null)
        {
            if (!slotTemplate.gameObject.activeSelf)
            {
                slotTemplate.gameObject.SetActive(true);
                slotTemplate.container.enabled = false;

                //Copy selected item values to slot template
                slotTemplate.count.color = selectedItemSlot.slot.count.color;
                slotTemplate.item.sprite = selectedItemSlot.slot.item.sprite;
                slotTemplate.item.color = selectedItemSlot.slot.item.color;
            }

            //Make template slot follow mouse position
            slotTemplate.container.rectTransform.position = Input.mousePosition;
            //Update item count
            slotTemplate.count.text = selectedItemSlot.slot.count.text;
            slotTemplate.count.enabled = selectedItemSlot.slot.count.enabled;
        }
        else
        {
            if (slotTemplate.gameObject.activeSelf)
            {
                slotTemplate.gameObject.SetActive(false);
            }
        }
    }
}
  • एक नई स्क्रिप्ट बनाएं, इसे "SC_SlotTemplate" नाम दें, फिर नीचे दिए गए कोड को इसके अंदर पेस्ट करें:

SC_SlotTemplate.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class SC_SlotTemplate : MonoBehaviour, IPointerClickHandler
{
    public Image container;
    public Image item;
    public Text count;

    [HideInInspector]
    public bool hasClicked = false;
    [HideInInspector]
    public SC_ItemCrafting craftingController;

    //Do this when the mouse is clicked over the selectable object this script is attached to.
    public void OnPointerClick(PointerEventData eventData)
    {
        hasClicked = true;
        craftingController.ClickEventRecheck();
    }
}

स्लॉट टेम्पलेट तैयार करना:

  • SC_SlotTemplate स्क्रिप्ट को "slot_template" ऑब्जेक्ट में संलग्न करें, और इसके वेरिएबल असाइन करें (उसी ऑब्जेक्ट पर छवि घटक "Container" वेरिएबल पर जाता है, चाइल्ड "Item" इमेज "Item" वेरिएबल पर जाता है, और एक चाइल्ड "Count" टेक्स्ट "Count" वेरिएबल पर जाता है)
  • "result_slot_template" ऑब्जेक्ट के लिए वही प्रक्रिया दोहराएं (इसमें SC_SlotTemplate स्क्रिप्ट संलग्न करें और उसी तरह वेरिएबल असाइन करें)।

क्राफ्ट सिस्टम तैयार करना:

  • कैनवास ऑब्जेक्ट में SC_ItemCrafting स्क्रिप्ट संलग्न करें, और इसके वेरिएबल असाइन करें ("प्लेयरस्लॉट्स" ऑब्जेक्ट "Player Slots Container" वेरिएबल पर जाता है, "CraftingSlots" ऑब्जेक्ट "Crafting Slots Container" वेरिएबल पर जाता है, "ResultSlot" ऑब्जेक्ट *h51 पर जाता है * वेरिएबल, "CraftButton" ऑब्जेक्ट "Craft Button" वेरिएबल में जाता है, "slot_template" ऑब्जेक्ट SC_SlotTemplate स्क्रिप्ट के साथ "Slot Template" वेरिएबल में जाता है और "result_slot_template" ऑब्जेक्ट SC_SlotTemplate स्क्रिप्ट के साथ संलग्न होकर "Result Slot Template" वेरिएबल में जाता है):

जैसा कि आपने पहले ही देखा है, "Player Slots" और "Items" नामक दो खाली सरणियाँ हैं। "Player Slots" में उपलब्ध स्लॉट की संख्या (आइटम या खाली के साथ) शामिल होगी और "Items" में सभी उपलब्ध आइटम उनके व्यंजनों (वैकल्पिक) के साथ शामिल होंगे।

आइटम सेट करना:

नीचे स्प्राइट की जाँच करें (मेरे मामले में मेरे पास 5 आइटम होंगे):

रॉक आइटम (चट्टान)

हीरे की वस्तु (हीरा)

लकड़ी की वस्तु (लकड़ी)

तलवार की वस्तु (तलवार)

हीरे की तलवार (हीरे की तलवार)

  • प्रत्येक स्प्राइट को डाउनलोड करें (राइट क्लिक -> इस रूप में सहेजें...) और उन्हें अपने प्रोजेक्ट में आयात करें (आयात सेटिंग्स में उनके बनावट प्रकार को "Sprite (2D and UI)" और फ़िल्टर मोड को सेट करें) "Point (no filter)"

  • SC_ItemCrafting में आइटम का आकार 5 में बदलें और प्रत्येक स्प्राइट को आइटम स्प्राइट वेरिएबल में असाइन करें।

"Stackable" वैरिएबल नियंत्रित करता है कि वस्तुओं को एक स्लॉट में एक साथ रखा जा सकता है या नहीं (उदा. आप केवल साधारण सामग्री जैसे चट्टान, हीरे और लकड़ी के लिए स्टैकिंग की अनुमति देना चाह सकते हैं)।

"Craft Recipe" परिवर्तनीय नियंत्रण यदि यह आइटम तैयार किया जा सकता है (खाली का मतलब है कि इसे तैयार नहीं किया जा सकता है)

  • "Player Slots" के लिए ऐरे साइज़ को 27 पर सेट करें (वर्तमान क्राफ्टिंग पैनल के लिए सबसे उपयुक्त, लेकिन आप कोई भी संख्या सेट कर सकते हैं)।

जब आप Play दबाते हैं, तो आप देखेंगे कि स्लॉट सही ढंग से आरंभ किए गए हैं, लेकिन कोई आइटम नहीं हैं:

प्रत्येक स्लॉट में एक आइटम जोड़ने के लिए हमें "Item Sprite" वेरिएबल के लिए एक आइटम स्प्राइट असाइन करना होगा और "Item Count" को किसी भी सकारात्मक संख्या पर सेट करना होगा (1 से कम की सभी चीजें, और/या गैर-स्टैकेबल आइटम को 1 के रूप में समझा जाएगा):

  • "rock" स्प्राइट को तत्व 0 / "Item Count" 14 को, "wood" स्प्राइट को तत्व 1 / "Item Count" 8 को, "diamond" स्प्राइट को तत्व 2 / "Item Count" 8 को असाइन करें (सुनिश्चित करें कि स्प्राइट समान हैं "Items" ऐरे में, अन्यथा यह काम नहीं करेगा)।

आइटम अब प्लेयर स्लॉट में दिखाई देने चाहिए, आप आइटम पर क्लिक करके और फिर उस स्लॉट पर क्लिक करके उनकी स्थिति बदल सकते हैं जहां आप इसे ले जाना चाहते हैं।

क्राफ्टिंग रेसिपी:

क्राफ्टिंग रेसिपी आपको एक विशिष्ट क्रम में अन्य वस्तुओं को मिलाकर एक आइटम बनाने की अनुमति देती है:

क्राफ्टिंग रेसिपी का प्रारूप इस प्रकार है: [आइटम_स्प्राइट_नाम]([आइटम गिनती])*वैकल्पिक... 9 बार दोहराया गया, अल्पविराम से अलग किया गया (,)

रेसिपी खोजने का एक आसान तरीका है प्ले दबाकर, फिर वस्तुओं को उस क्रम में रखें जिसे आप बनाना चाहते हैं, फिर "Craft" दबाएँ, उसके बाद, Unity कंसोल खोलने के लिए (Ctrl + Shift + C) दबाएँ और देखें नई मुद्रित लाइन (आप लाइन को दोबारा प्रिंट करने के लिए "Craft" पर कई बार क्लिक कर सकते हैं), मुद्रित लाइन क्राफ्टिंग नुस्खा है।

उदाहरण के लिए, नीचे दिया गया संयोजन इस रेसिपी से मेल खाता है: रॉक, रॉक, रॉक, रॉक, लकड़ी (नोट: यदि आपके स्प्राइट के अलग-अलग नाम हैं तो यह आपके लिए अलग हो सकता है)।

तलवार आइटम क्राफ्टिंग रेसिपी

हम तलवार बनाने के लिए उपरोक्त नुस्खा का उपयोग करेंगे।

  • मुद्रित लाइन की प्रतिलिपि बनाएँ, और "Items" ऐरे में इसे "sword" आइटम के अंतर्गत "Craft Recipe" वेरिएबल में पेस्ट करें:

अब उसी संयोजन को दोहराते समय आपको तलवार बनाने में सक्षम होना चाहिए।

हीरे की तलवार का नुस्खा एक ही है, लेकिन चट्टान के बजाय यह हीरा है:

डायमंड आइटम तलवार पकाने की विधि एकता निरीक्षक

यूनिटी इन्वेंटरी सिस्टम और आइटम क्राफ्टिंग

क्राफ्टिंग सिस्टम अब तैयार है.

स्रोत
📁ItemCrafting.unitypackage36.13 KB
यूनिटी3डीयूनिटीट्यूटोरियलइन्वेंट्रीक्राफ्टिंगसिस्टमआइटमड्रैगड्रॉपयूआईस्क्रिप्टकोडिंगक्राफ्टरेसिपीतलवाररॉकलकड़ीहीरास्प्राइटछवि
सुझाए गए लेख
यूआई ड्रैग एंड ड्रॉप इन यूनिटी के साथ एक सरल इन्वेंटरी सिस्टम को कोडिंग
एकता में राज्य मशीन का परिचय
एकता में कटसीन को कैसे ट्रिगर करें
एकता में इन्वेंटरी के बिना पिक एंड ड्रॉप सिस्टम
एकता में एक पैक-मैन-प्रेरित गेम बनाना
एकता में संग्रहणीय वस्तुएं और पावर-अप बनाना
एकता में इंटरएक्टिव ऑब्जेक्ट बनाना
अधिक पोस्ट »
लोकप्रिय लेख
यूनिटी ऑबफस्केशन मेथड्स और एंटी-हैक प्रोटेक्शन
यूनिटी कोड में अपवादों और त्रुटि प्रबंधन को संभालना
एकता पदयात्रा ध्वनि को क्रियान्वित कर रही है
C# में उपयोगी कीवर्ड की एकता सूची
यूआई ड्रैग एंड ड्रॉप इन यूनिटी के साथ एक सरल इन्वेंटरी सिस्टम को कोडिंग
यूनिटी सी# इंटरफ़ेस शुरुआती गाइड
एकता में एकाधिक उप-चर वाले चर