Beispiel #1
0
        //合成东西
        public void CraftingItem()
        {
            if (inv.ReturnCoolingState(slot))
            {
                Q_GameMaster.Instance.inventoryManager.SetInformation(Q_GameMaster.Instance.inventoryManager.infoManager.cantCrafting);
                return;
            }

            if (m_CraftingBluePrint.CDAllWhenCrafting)
            {
                for (int i = 0; i < inv.items.Count; i++)
                {
                    if (inv.ReturnCoolingState(i))
                    {
                        Q_GameMaster.Instance.inventoryManager.SetInformation(Q_GameMaster.Instance.inventoryManager.infoManager.cantCrafting);
                        Debug.Log("cant crafting");
                        return;
                    }
                }
            }


            if (!isCrafting)
            {
                float tempTotalPrice = 0;
                foreach (Price m_Price in m_CraftingBluePrint.craftingPrices)
                {
                    tempTotalPrice += m_Price.amount * m_Price.currency.exchangeRate;
                }

                if (Q_GameMaster.Instance.inventoryManager.playerInventoryManager.totalCurrencyValue < tempTotalPrice * amountToCraft)
                {
                    Q_GameMaster.Instance.inventoryManager.SetInformation(Q_GameMaster.Instance.inventoryManager.infoManager.lockMoney);
                    Debug.Log("Cant Afford Crafting");
                }
                else
                {
                    bool canCrafting = m_Crafting.CraftingItem(this);
                    if (canCrafting)
                    {
                        //UpdataPlayerCurrency(m_CraftingBluePrint.craftingPrices, -amountToCraft);
                        isCrafting = true;

                        if (m_CraftingBluePrint.moveAfterCrafting)
                        {
                            StartCoroutine(DeleteAfterCrafting(m_CraftingBluePrint.craftingTime));
                        }
                    }
                    else
                    {
                        Q_GameMaster.Instance.inventoryManager.SetInformation(Q_GameMaster.Instance.inventoryManager.infoManager.lockIngredient);
                        //Q_GameMaster.Instance.inventoryManager.informationText.text = "Dont Have Enough Ingredients";
                        //Q_GameMaster.Instance.inventoryManager.informationPanel.SetActive(true);

                        Debug.Log("Don't Have Enough Ingredients");
                    }
                }
            }
        }
        public void OnBeginDrag(PointerEventData eventData)
        {
            if (itemData.item != null)
            {
                if (inv.tag == "Equipment")
                {
                    return;
                }

                if ((inv.tag == "Inventory" || inv.tag == "SkillBar"))
                {
                    if (inv.ReturnCoolingState(itemData.slot))
                    {
                        return;
                    }
                }

                //offset = eventData.position - (Vector2)transform.position;
                transform.SetParent(Q_GameMaster.Instance.inventoryManager.Canvas.transform);
                //transform.position = eventData.position - offset;
                transform.position = eventData.position;
                GetComponent <CanvasGroup>().blocksRaycasts = false;
            }
        }
        public void SortItem()
        {
            List <ItemToSort> itemsToSort = new List <ItemToSort>();
            Q_Inventory       inv         = GetComponent <Q_Inventory>();

            if (inv.tag == "Inventory")
            {
                for (int i = 0; i < inv.slots.Count; i++)
                {
                    if (inv.ReturnCoolingState(i))
                    {
                        return;
                    }
                }
            }

            foreach (var slot in inv.slots)
            {
                if (slot.transform.childCount > 0)
                {
                    ItemData data = slot.transform.GetChild(0).GetComponent <ItemData>();
                    itemsToSort.Add(new ItemToSort(data.item, data.amount));
                    data.ClearItem();
                }
            }

            List <Variety> itemSortingOrders = Q_GameMaster.Instance.inventoryManager.itemSortingManager.itemSortingOrders;

            foreach (var sortType in itemSortingOrders)
            {
                foreach (var itemToSort in itemsToSort)
                {
                    if (itemToSort.item.variety == sortType)
                    {
                        StartCoroutine(ItemAdd(itemToSort.item.ID, itemToSort.amount));
                    }
                }
            }
        }
Beispiel #4
0
        public void OnDrop(PointerEventData eventData)
        {
            ItemData droppedItem = eventData.pointerDrag.GetComponent <ItemData>();

            if (!droppedItem)
            {
                return;
            }
            if (!droppedItem.inv)
            {
                return;
            }
            if (droppedItem.inv.tag == "Equipment")
            {
                return;
            }
            if ((droppedItem.inv.tag == "Inventory" || inv.tag == "SkillBar"))
            {
                if (droppedItem.inv.ReturnCoolingState(droppedItem.slot))
                {
                    //Q_GameMaster.Instance.inventoryManager.SetInformation(Q_GameMaster.Instance.inventoryManager.infoManager.cantMoveWhenCD);
                    return;
                }
            }

            string tag = eventData.pointerCurrentRaycast.gameObject.tag;

            if (tag == "Storage" || tag == "Inventory" || tag == "SkillBar")
            {
                //Debug.Log(eventData.pointerCurrentRaycast.gameObject.tag);
                if (inv.items[slotID].ID == -1)
                {
                    if (droppedItem.inv == inv)
                    {
                        if (droppedItem.inv.items[droppedItem.slot] != null)
                        {
                            droppedItem.inv.items[droppedItem.slot] = Item.CreateInstance <Item>();
                        }
                        inv.items[slotID] = droppedItem.item;
                        if (tag == "Inventory" || tag == "SkillBar")
                        {
                            inv.cds[slotID]           = inv.cds[droppedItem.slot];
                            inv.cds[droppedItem.slot] = new CoolDown();
                        }

                        droppedItem.slot = slotID;
                    }

                    else
                    {
                        inv.AddItem(droppedItem.item, slotID, droppedItem.amount);

                        droppedItem.ClearItem();
                    }
                }

                else if ((inv.tag == "Inventory" || inv.tag == "SkillBar") && inv.ReturnCoolingState(slotID))
                {
                    return;
                }

                else if ((droppedItem.inv.tag == "Inventory" || droppedItem.inv.tag == "SkillBar") &&
                         droppedItem.inv.ReturnCoolingState(droppedItem.slot))
                {
                    return;
                }

                else
                {
                    Transform item     = null;
                    int       chileNum = transform.childCount;
                    if (chileNum == 1)
                    {
                        item = transform.GetChild(0);
                    }
                    else if (chileNum == 2)
                    {
                        item = transform.GetChild(1);
                    }

                    ItemData data = null;
                    if (item)
                    {
                        data = item.GetComponent <ItemData>();
                    }


                    if (droppedItem.inv == inv)
                    {
                        if (!item)
                        {
                            return;
                        }
                        //Debug.Log("Switch");
                        if (data)
                        {
                            data.slot = droppedItem.slot;
                        }
                        item.transform.SetParent(data.inv.slots[droppedItem.slot].transform);
                        item.transform.position          = data.inv.slots[droppedItem.slot].transform.position;
                        data.inv.items[droppedItem.slot] = data.item;
                        inv.items[slotID] = droppedItem.item;

                        if (inv.tag == "Inventory" || inv.tag == "SkillBar")
                        {
                            inv.cds[droppedItem.slot]   = new CoolDown(data.cd, data.item.coolDown);
                            droppedItem.inv.cds[slotID] = new CoolDown(droppedItem.cd, droppedItem.item.coolDown);
                        }

                        droppedItem.slot = slotID;
                        droppedItem.transform.SetParent(transform);
                        droppedItem.transform.position = transform.position;
                        //data.inv = droppedItem.inv;
                        //item.GetComponent<ItemDrag>().inv = droppedItem.inv;

                        //droppedItem.inv = inv;
                        //droppedItem.GetComponent<ItemDrag>().inv = inv;
                    }

                    else
                    {
                        if (data.item == droppedItem.item && data.item.isStackable &&
                            inv.CheckSlot(slotID) > droppedItem.amount)
                        {
                            droppedItem.ClearItem();
                            data.amount += droppedItem.amount;
                            data.UpdataText();
                        }

                        else
                        {
                            data.ClearItem();
                            droppedItem.ClearItem();

                            int temp = data.slot;
                            data.slot        = droppedItem.slot;
                            droppedItem.slot = temp;

                            droppedItem.inv.AddItem(data.item, data.slot, data.amount);
                            inv.AddItem(droppedItem.item, droppedItem.slot, droppedItem.amount);
                        }
                    }
                }
            }
        }