OnUpdateItemList() public method

public OnUpdateItemList ( ) : void
return void
コード例 #1
0
ファイル: DragItem.cs プロジェクト: jinxka/On_The_Road
    public void OnDrag(PointerEventData data)
    {
        if (rectTransform == null)
        {
            return;
        }

        if (data.button == PointerEventData.InputButton.Left && transform.parent.GetComponent <CraftResultSlot>() == null)
        {
            rectTransform.SetAsLastSibling();
            transform.SetParent(draggedItemBox);                                                       // icon placed into empty object
            Vector2 localPointerPosition;
            canvasGroup.blocksRaycasts = false;
            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransformSlot, Input.mousePosition, data.pressEventCamera, out localPointerPosition))  // follow mouse
            {
                rectTransform.localPosition = localPointerPosition - pointerOffset;
                if (transform.GetComponent <ConsumeItem>().duplication != null)
                {
                    Destroy(transform.GetComponent <ConsumeItem>().duplication);
                }
            }
        }

        inventory.OnUpdateItemList();
    }
コード例 #2
0
    void putItem(Transform selectedItem, float offSetY, Vector3 fixedPos)
    {
        GameObject dropItem = (GameObject)Instantiate(selectedItem.GetComponent <ItemOnObject>().item.itemModel);
        Item       item     = itemDataBase.getItemByID(selectedItem.GetComponent <ItemOnObject> ().item.itemID);

        dropItem.AddComponent <PickUpItem>();
        dropItem.GetComponent <PickUpItem> ().item = item;

        dropItem.AddComponent <ItemRef> ();
        dropItem.GetComponent <ItemRef> ().item = item;
//		dropItem.GetComponent<PickUpItem>().item = selectedItem.GetComponent<ItemOnObject>().item;

        /* Put the item to this position */
        if (fixedPos == Vector3.zero)
        {
            dropItem.transform.localPosition = new Vector3(_player.transform.localPosition.x, _player.transform.localPosition.y + offSetY, _player.transform.localPosition.z + 1.0f);
        }
        else
        {
            dropItem.transform.localPosition = fixedPos;
        }

        Inventory inv = GetComponent <Inventory> ();

        removeItem(selectedItem);
        inv.OnUpdateItemList();

        // SceneManager
        if (sceneManager.GameSceneIsPreview())
        {
            sceneManager.addToGearList(dropItem);
        }
    }
コード例 #3
0
    void addItemGUI()                                                                                                       //add a item to the inventory through the inspector
    {
        if (!inv.characterSystem())
        {
            GUILayout.Label("Add an item:");
            inv.setImportantVariables();                                                                                      //space to the top gui element
            EditorGUILayout.BeginHorizontal();                                                                                //starting horizontal GUI elements
            ItemDataBaseList inventoryItemList = (ItemDataBaseList)Resources.Load("ItemDatabase");                            //loading the itemdatabase
            string[]         items             = new string[inventoryItemList.itemList.Count];                                //create a string array in length of the itemcount
            for (int i = 1; i < items.Length; i++)                                                                            //go through the item array
            {
                items[i] = inventoryItemList.itemList[i].itemName;                                                            //and paste all names into the array
            }
            itemID    = EditorGUILayout.Popup("", itemID, items, EditorStyles.popup);                                         //create a popout with all itemnames in it and save the itemID of it
            itemValue = EditorGUILayout.IntField("", itemValue, GUILayout.Width(40));
            GUI.color = Color.green;                                                                                          //set the color of all following guielements to green
            if (GUILayout.Button("Add Item"))                                                                                 //creating button with name "AddItem"
            {
                inv.addItemToInventory(itemID, itemValue);                                                                    //and set the settings for possible stackedItems
                inv.stackableSettings();
            }
            inv.OnUpdateItemList();

            EditorGUILayout.EndHorizontal();                                                                                    //end the horizontal gui layout
        }
    }
コード例 #4
0
    public void consumeIt()
    {
        Inventory inventory = transform.parent.parent.parent.GetComponent <Inventory>();

        bool gearable = false;

        if (GameObject.FindGameObjectWithTag("EquipmentSystem") != null)
        {
            eS = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().characterSystem.GetComponent <EquipmentSystem>();
        }

        if (eS != null)
        {
            itemTypeOfSlot = eS.itemTypeOfSlots;
        }

        Item itemFromDup = null;

        if (duplication != null)
        {
            itemFromDup = duplication.GetComponent <ItemOnObject>().item;
        }

        bool stop = false;

        if (eS != null)
        {
            for (int i = 0; i < eS.slotsInTotal; i++)
            {
                if (itemTypeOfSlot[i].Equals(item.itemType))
                {
                    if (eS.transform.GetChild(1).GetChild(i).childCount == 0)
                    {
                        stop = true;
                        this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                        this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                        eS.gameObject.GetComponent <Inventory>().updateItemList();
                        inventory.updateItemList();
                        inventory.EquiptItem(item);
                        gearable = true;
                        if (duplication != null)
                        {
                            Destroy(duplication.gameObject);
                        }
                        break;
                    }
                }
            }

            if (!stop)
            {
                for (int i = 0; i < eS.slotsInTotal; i++)
                {
                    if (itemTypeOfSlot[i].Equals(item.itemType))
                    {
                        if (eS.transform.GetChild(1).GetChild(i).childCount != 0)
                        {
                            GameObject otherItemFromCharacterSystem = eS.transform.GetChild(1).GetChild(i).GetChild(0).gameObject;
                            Item       otherSlotItem = otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item;
                            if (item.itemType == ItemType.UFPS_Weapon)
                            {
                                inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                inventory.EquiptItem(item);
                            }
                            else
                            {
                                inventory.EquiptItem(item);
                                if (item.itemType != ItemType.Backpack)
                                {
                                    inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                }
                            }
                            if (this == null)
                            {
                                GameObject dropItem = (GameObject)Instantiate(otherSlotItem.itemModel);
                                dropItem.AddComponent <PickUpItem>();
                                dropItem.GetComponent <PickUpItem>().item = otherSlotItem;
                                dropItem.transform.localPosition          = GameObject.FindGameObjectWithTag("Player").transform.localPosition;
                                inventory.OnUpdateItemList();
                            }
                            else
                            {
                                otherItemFromCharacterSystem.transform.SetParent(this.transform.parent);
                                otherItemFromCharacterSystem.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                if (this.gameObject.transform.parent.parent.parent.GetComponent <Hotbar>() != null)
                                {
                                    createDuplication(otherItemFromCharacterSystem);
                                }

                                this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                                this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                            }

                            gearable = true;
                            if (duplication != null)
                            {
                                Destroy(duplication.gameObject);
                            }
                            eS.gameObject.GetComponent <Inventory>().updateItemList();
                            inventory.OnUpdateItemList();
                            break;
                        }
                    }
                }
            }
        }
        if (!gearable && item.itemType != ItemType.UFPS_Ammo && item.itemType != ItemType.UFPS_Grenade)
        {
            if (duplication != null)
            {
                itemFromDup = duplication.GetComponent <ItemOnObject>().item;
            }

            inventory.ConsumeItem(item);

            item.itemValue--;
            if (itemFromDup != null)
            {
                duplication.GetComponent <ItemOnObject>().item.itemValue--;
                if (itemFromDup.itemValue <= 0)
                {
                    if (tooltip != null)
                    {
                        tooltip.deactivateTooltip();
                    }
                    inventory.deleteItemFromInventory(item);
                    Destroy(duplication.gameObject);
                }
            }
            if (item.itemValue <= 0)
            {
                if (tooltip != null)
                {
                    tooltip.deactivateTooltip();
                }
                inventory.deleteItemFromInventory(item);
                Destroy(this.gameObject);
            }
        }
    }
コード例 #5
0
    public void OnPointerDown(PointerEventData data)
    {
        if (this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() == null)
        {
            bool      gearable  = false;
            Inventory inventory = transform.parent.parent.parent.GetComponent <Inventory>();

            if (eS != null)
            {
                itemTypeOfSlot = eS.itemTypeOfSlots;
            }

            if (data.button == PointerEventData.InputButton.Right)
            {
                //item from craft system to inventory
                if (transform.parent.GetComponent <CraftResultSlot>() != null)
                {
                    bool check = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().inventory.GetComponent <Inventory>().checkIfItemAllreadyExist(item.itemID, item.itemValue);

                    if (!check)
                    {
                        GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().inventory.GetComponent <Inventory>().addItemToInventory(item.itemID, item.itemValue);
                        GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().inventory.GetComponent <Inventory>().stackableSettings();
                    }
                    CraftSystem cS = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().craftSystem.GetComponent <CraftSystem>();
                    cS.deleteItems(item);
                    CraftResultSlot result = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().craftSystem.transform.GetChild(3).GetComponent <CraftResultSlot>();
                    result.temp = 0;
                    //tooltip.deactivateTooltip();
                    gearable = true;
                    GameObject.FindGameObjectWithTag("MainInventory").GetComponent <Inventory>().updateItemList();
                }
                else
                {
                    bool stop = false;
                    if (eS != null)
                    {
                        for (int i = 0; i < eS.slotsInTotal; i++)
                        {
                            if (itemTypeOfSlot[i].Equals(item.itemType))
                            {
                                if (eS.transform.GetChild(1).GetChild(i).childCount == 0)
                                {
                                    stop = true;
                                    if (eS.transform.GetChild(1).GetChild(i).parent.parent.GetComponent <EquipmentSystem>() != null && this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() != null)
                                    {
                                    }
                                    else
                                    {
                                        inventory.EquiptItem(item);
                                    }

                                    this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                                    this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                    eS.gameObject.GetComponent <Inventory>().updateItemList();
                                    inventory.updateItemList();
                                    gearable = true;
                                    if (duplication != null)
                                    {
                                        Destroy(duplication.gameObject);
                                    }
                                    break;
                                }
                            }
                        }


                        if (!stop)
                        {
                            for (int i = 0; i < eS.slotsInTotal; i++)
                            {
                                if (itemTypeOfSlot[i].Equals(item.itemType))
                                {
                                    if (eS.transform.GetChild(1).GetChild(i).childCount != 0)
                                    {
                                        GameObject otherItemFromCharacterSystem = eS.transform.GetChild(1).GetChild(i).GetChild(0).gameObject;
                                        Item       otherSlotItem = otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item;
                                        if (item.itemType == ItemType.UFPS_Weapon)
                                        {
                                            inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                            inventory.EquiptItem(item);
                                        }
                                        else
                                        {
                                            inventory.EquiptItem(item);
                                            if (item.itemType != ItemType.Backpack)
                                            {
                                                inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                            }
                                        }
                                        if (this == null)
                                        {
                                            GameObject dropItem = (GameObject)Instantiate(otherSlotItem.itemModel);
                                            dropItem.AddComponent <PickUpItem>();
                                            dropItem.GetComponent <PickUpItem>().item = otherSlotItem;
                                            dropItem.transform.localPosition          = GameObject.FindGameObjectWithTag("Player").transform.localPosition;
                                            inventory.OnUpdateItemList();
                                        }
                                        else
                                        {
                                            otherItemFromCharacterSystem.transform.SetParent(this.transform.parent);
                                            otherItemFromCharacterSystem.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                            if (this.gameObject.transform.parent.parent.parent.GetComponent <Hotbar>() != null)
                                            {
                                                createDuplication(otherItemFromCharacterSystem);
                                            }

                                            this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                                            this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                        }

                                        gearable = true;
                                        if (duplication != null)
                                        {
                                            Destroy(duplication.gameObject);
                                        }
                                        eS.gameObject.GetComponent <Inventory>().updateItemList();
                                        inventory.OnUpdateItemList();
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                if (!gearable && item.itemType != ItemType.UFPS_Ammo && item.itemType != ItemType.UFPS_Grenade)
                {
                    Item itemFromDup = null;
                    if (duplication != null)
                    {
                        itemFromDup = duplication.GetComponent <ItemOnObject>().item;
                    }

                    inventory.ConsumeItem(item);

                    item.itemValue--;
                    if (itemFromDup != null)
                    {
                        duplication.GetComponent <ItemOnObject>().item.itemValue--;
                        if (itemFromDup.itemValue <= 0)
                        {
                            if (tooltip != null)
                            {
                                tooltip.deactivateTooltip();
                            }
                            inventory.deleteItemFromInventory(item);
                            Destroy(duplication.gameObject);
                        }
                    }
                    if (item.itemValue <= 0)
                    {
                        if (tooltip != null)
                        {
                            tooltip.deactivateTooltip();
                        }
                        inventory.deleteItemFromInventory(item);
                        Destroy(this.gameObject);
                    }
                }
            }
        }
    }
コード例 #6
0
ファイル: DragItem.cs プロジェクト: warlocksuper/trendcity
    public void OnEndDrag(PointerEventData data)
    {
        if (data.button == PointerEventData.InputButton.Left)
        {
            canvasGroup.blocksRaycasts = true;
            Transform newSlot = null;
            if (data.pointerEnter != null)
            {
                newSlot = data.pointerEnter.transform;
            }

            if (newSlot != null)
            {
                //getting the items from the slots, GameObjects and RectTransform
                GameObject    firstItemGameObject     = this.gameObject;
                GameObject    secondItemGameObject    = newSlot.parent.gameObject;
                RectTransform firstItemRectTransform  = this.gameObject.GetComponent <RectTransform>();
                RectTransform secondItemRectTransform = newSlot.parent.GetComponent <RectTransform>();

                if (secondItemRectTransform == null)
                {
                    return;
                }
                bool byitemonitem = false;
                Item firstItem    = rectTransform.GetComponent <ItemOnObject>().item;
                Item secondItem   = new Item();
                if (newSlot.parent.GetComponent <ItemOnObject>() != null)
                {
                    secondItem = newSlot.parent.GetComponent <ItemOnObject>().item;
                }

                if (secondItemRectTransform.gameObject.name != "PlayerGui")
                {
                    if (firstItemRectTransform.gameObject.name == "Item(Clone)" && secondItemRectTransform.gameObject.name == "Item(Clone)")
                    {
                        Debug.Log("Dragitem " + secondItemRectTransform.parent.parent.parent.name);
                        if (secondItemRectTransform.parent.parent.parent.tag == "MainInventory" || secondItemRectTransform.parent.parent.parent.tag == "Hotbar")
                        {
                            byitemonitem = true;
                        }
                    }
                    //Debug.Log("Error By " + firstItem.outbox.tag+"secondItemRectTransform "+ secondItemRectTransform.gameObject.name);
                    if ((firstItem.outbox.tag == "Shop" && secondItemRectTransform.parent.gameObject.tag == "MainInventory") || (firstItem.outbox.tag == "Shop" && secondItemRectTransform.parent.gameObject.tag == "Hotbar") || byitemonitem)
                    {
                        int pricemengnt = firstItem.price * 10;
                        int PlayerMoney = 0;
                        if (playerIO.isNetwork)
                        {
                            PlayerMoney = networkLayerClient.player.money;
                        }
                        else
                        {
                            PlayerMoney = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
                        }

                        if (PlayerMoney < pricemengnt)
                        {
                            if (playerIO.isNetwork)
                            {
                                MenuManager.instance.Debuglog("Нехватает денег");
                            }
                            else
                            {
                                GameObject.Find("GameLocal").GetComponent <Gamelocal>().Debuglog("Нехватает денег");
                            }
                            Item      returitem     = firstItem;
                            Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
                            //Component[] components = returitem.outbox.GetComponents<Inventory>();
                            shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
                            shopinventory.OnUpdateItemList();
                            Destroy(rectTransform.gameObject);
                            return;
                        }
                        else
                        {
                            if (playerIO.isNetwork)
                            {
                                PlayerMoney = networkLayerClient.player.money;
                                networkLayerClient.buy_items(firstItem, 1);
                                //buy_items
                            }
                            else
                            {
                                PlayerMoney -= pricemengnt;
                                PlayerMoney  = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
                                Inventory playerinventory = GameObject.Find("PlayerGui").transform.GetChild(1).GetComponent <Inventory>();
                                //createDuplication(GameObject Item)
                                if (!playerinventory.checkIfItemAllreadyExist(firstItem.itemID, 1))
                                {
                                    playerinventory.addItemToInventory(firstItem.itemID);
                                }
                            }


                            Item      returitem     = firstItem;
                            Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
                            //Component[] components = returitem.outbox.GetComponents<Inventory>();
                            shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);

                            shopinventory.OnUpdateItemList();
                            Destroy(rectTransform.gameObject);

                            return;
                        }

                        //  Debug.Log("By item previem box" + firstItem.outbox.tag + " newSlot" + secondItemRectTransform.parent.gameObject.tag);
                    }
                }

                if (secondItemRectTransform.gameObject.name == "PlayerGui")
                {
                    Item      returitem     = firstItem;
                    Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
                    //Component[] components = returitem.outbox.GetComponents<Inventory>();
                    shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
                    shopinventory.OnUpdateItemList();

                    Destroy(rectTransform.gameObject);
                    return;
                }


                if (firstItemRectTransform.gameObject.name == "Item(Clone)" && secondItemRectTransform.gameObject.name == "Item(Clone)")
                {
                    Debug.Log("Dragitem " + secondItemRectTransform.parent.parent.parent.name);
                    if (secondItemRectTransform.parent.parent.parent.tag == "Shop")
                    {
                        byitemonitem = true;
                    }
                }

                if ((firstItem.outbox.tag == "MainInventory" && secondItemRectTransform.parent.gameObject.tag == "Shop") || (firstItem.outbox.tag == "Hotbar" && secondItemRectTransform.parent.gameObject.tag == "Shop") || byitemonitem)
                {
                    // Gamelocal.instance.PlayerMoney = Gamelocal.instance.PlayerMoney + (firstItem.price * firstItem.itemValue);
                    if (playerIO.isNetwork)
                    {
                        networkLayerClient.sell_items(firstItem);
                    }
                    else
                    {
                        int PlayerMoney = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
                        PlayerMoney += firstItem.price * firstItem.itemValue;
                        GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney = PlayerMoney;
                    }
                    Destroy(rectTransform.gameObject);
                    Debug.Log("Sell item previem box" + firstItem.outbox.tag + " newSlot" + secondItemRectTransform.parent.gameObject.tag);
                    return;
                }
                //get some informations about the two items
                bool sameItem            = firstItem.itemName == secondItem.itemName;
                bool sameItemRerferenced = firstItem.Equals(secondItem);
                bool secondItemStack     = false;
                bool firstItemStack      = false;
                if (sameItem)
                {
                    firstItemStack  = firstItem.itemValue < firstItem.maxStack;
                    secondItemStack = secondItem.itemValue < secondItem.maxStack;
                }

                // Debug.Log("Error By " + firstItemRectTransform.gameObject.name + " secondItemRectTransform "+ secondItemRectTransform.gameObject.name);
                if (secondItemRectTransform.gameObject.name == "PlayerGui")
                {
                    Item      returitem     = firstItem;
                    Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
                    //Component[] components = returitem.outbox.GetComponents<Inventory>();
                    shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
                    shopinventory.OnUpdateItemList();

                    Destroy(rectTransform.gameObject);
                    return;
                }

                GameObject Inventory = secondItemRectTransform.parent.gameObject;
                if (Inventory.tag == "Slot")
                {
                    Inventory = secondItemRectTransform.parent.parent.parent.gameObject;
                }

                if (Inventory.tag.Equals("Slot"))
                {
                    Inventory = Inventory.transform.parent.parent.gameObject;
                }

                //dragging in an Inventory
                if (Inventory.GetComponent <Hotbar>() == null && Inventory.GetComponent <EquipmentSystem>() == null && Inventory.GetComponent <CraftSystem>() == null)
                {
                    //you cannot attach items to the resultslot of the craftsystem
                    if (newSlot.transform.parent.tag == "ResultSlot" || newSlot.transform.tag == "ResultSlot" || newSlot.transform.parent.parent.tag == "ResultSlot")
                    {
                        firstItemGameObject.transform.SetParent(oldSlot.transform);
                        firstItemRectTransform.localPosition = Vector3.zero;
                    }
                    else
                    {
                        int  newSlotChildCount = newSlot.transform.parent.childCount;
                        bool isOnSlot          = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
                        //dragging on a slot where allready is an item on
                        if (newSlotChildCount != 0 && isOnSlot)
                        {
                            //check if the items fits into the other item
                            bool fitsIntoStack = false;
                            if (sameItem)
                            {
                                fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
                            }
                            //if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items

                            if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
                            {
                                //if the item does not fit into the other item
                                if (fitsIntoStack && !sameItemRerferenced)
                                {
                                    secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
                                    secondItemGameObject.transform.SetParent(newSlot.parent.parent);
                                    Destroy(firstItemGameObject);
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                    if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
                                    {
                                        GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
                                        dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
                                        dup.GetComponent <SplitItem>().inv.stackableSettings();
                                        dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
                                    }
                                }

                                else
                                {
                                    //creates the rest of the item
                                    int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;

                                    //fill up the other stack and adds the rest to the other stack
                                    if (!fitsIntoStack && rest > 0)
                                    {
                                        firstItem.itemValue  = firstItem.maxStack;
                                        secondItem.itemValue = rest;

                                        firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                        secondItemGameObject.transform.SetParent(oldSlot.transform);

                                        firstItemRectTransform.localPosition  = Vector3.zero;
                                        secondItemRectTransform.localPosition = Vector3.zero;
                                    }
                                }
                            }
                            //if does not fit
                            else
                            {
                                //creates the rest of the item
                                int rest = 0;
                                if (sameItem)
                                {
                                    rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
                                }

                                //fill up the other stack and adds the rest to the other stack
                                if (!fitsIntoStack && rest > 0)
                                {
                                    secondItem.itemValue = firstItem.maxStack;
                                    firstItem.itemValue  = rest;

                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);

                                    firstItemRectTransform.localPosition  = Vector3.zero;
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                }
                                //if they are different items or the stack is full, they get swapped
                                else if (!fitsIntoStack && rest == 0)
                                {
                                    //if you are dragging an item from equipmentsystem to the inventory and try to swap it with the same itemtype
                                    if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType == secondItem.itemType)
                                    {
                                        newSlot.transform.parent.parent.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
                                        oldSlot.transform.parent.parent.GetComponent <Inventory>().EquiptItem(secondItem);

                                        firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                        secondItemGameObject.transform.SetParent(oldSlot.transform);
                                        secondItemRectTransform.localPosition = Vector3.zero;
                                        firstItemRectTransform.localPosition  = Vector3.zero;

                                        if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
                                        {
                                            Destroy(secondItemGameObject.GetComponent <ConsumeItem>().duplication);
                                        }
                                    }
                                    //if you are dragging an item from the equipmentsystem to the inventory and they are not from the same itemtype they do not get swapped.
                                    else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType != secondItem.itemType)
                                    {
                                        firstItemGameObject.transform.SetParent(oldSlot.transform);
                                        firstItemRectTransform.localPosition = Vector3.zero;
                                    }
                                    //swapping for the rest of the inventorys
                                    else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null)
                                    {
                                        firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                        secondItemGameObject.transform.SetParent(oldSlot.transform);
                                        secondItemRectTransform.localPosition = Vector3.zero;
                                        firstItemRectTransform.localPosition  = Vector3.zero;
                                    }
                                }
                            }
                        }

                        //empty slot
                        else
                        {
                            if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
                            {
                                firstItemGameObject.transform.SetParent(oldSlot.transform);
                                firstItemRectTransform.localPosition = Vector3.zero;
                            }
                            else
                            {
                                firstItemGameObject.transform.SetParent(newSlot.transform);
                                firstItemRectTransform.localPosition = Vector3.zero;

                                if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
                                {
                                    oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
                                }
                            }
                        }
                    }
                }



                //dragging into a Hotbar
                if (Inventory.GetComponent <Hotbar>() != null)
                {
                    int  newSlotChildCount = newSlot.transform.parent.childCount;
                    bool isOnSlot          = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
                    //dragging on a slot where allready is an item on
                    if (newSlotChildCount != 0 && isOnSlot)
                    {
                        //check if the items fits into the other item
                        bool fitsIntoStack = false;
                        if (sameItem)
                        {
                            fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
                        }
                        //if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items

                        if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
                        {
                            //if the item does not fit into the other item
                            if (fitsIntoStack && !sameItemRerferenced)
                            {
                                secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
                                secondItemGameObject.transform.SetParent(newSlot.parent.parent);
                                Destroy(firstItemGameObject);
                                secondItemRectTransform.localPosition = Vector3.zero;
                                if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
                                {
                                    GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
                                    dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
                                    Inventory.GetComponent <Inventory>().stackableSettings();
                                    dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
                                }
                            }

                            else
                            {
                                //creates the rest of the item
                                int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;

                                //fill up the other stack and adds the rest to the other stack
                                if (!fitsIntoStack && rest > 0)
                                {
                                    firstItem.itemValue  = firstItem.maxStack;
                                    secondItem.itemValue = rest;

                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);

                                    firstItemRectTransform.localPosition  = Vector3.zero;
                                    secondItemRectTransform.localPosition = Vector3.zero;

                                    createDuplication(this.gameObject);
                                    secondItemGameObject.GetComponent <ConsumeItem>().duplication.GetComponent <ItemOnObject>().item = secondItem;
                                    secondItemGameObject.GetComponent <SplitItem>().inv.stackableSettings();
                                }
                            }
                        }
                        //if does not fit
                        else
                        {
                            //creates the rest of the item
                            int rest = 0;
                            if (sameItem)
                            {
                                rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
                            }

                            bool fromEquip = oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null;

                            //fill up the other stack and adds the rest to the other stack
                            if (!fitsIntoStack && rest > 0)
                            {
                                secondItem.itemValue = firstItem.maxStack;
                                firstItem.itemValue  = rest;

                                createDuplication(this.gameObject);

                                firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                secondItemGameObject.transform.SetParent(oldSlot.transform);

                                firstItemRectTransform.localPosition  = Vector3.zero;
                                secondItemRectTransform.localPosition = Vector3.zero;
                            }
                            //if they are different items or the stack is full, they get swapped
                            else if (!fitsIntoStack && rest == 0)
                            {
                                if (!fromEquip)
                                {
                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                    firstItemRectTransform.localPosition  = Vector3.zero;

                                    if (oldSlot.transform.parent.parent.gameObject.Equals(GameObject.FindGameObjectWithTag("MainInventory")))
                                    {
                                        Destroy(secondItemGameObject.GetComponent <ConsumeItem>().duplication);
                                        createDuplication(firstItemGameObject);
                                    }
                                    else
                                    {
                                        createDuplication(firstItemGameObject);
                                    }
                                }
                                else
                                {
                                    firstItemGameObject.transform.SetParent(oldSlot.transform);
                                    firstItemRectTransform.localPosition = Vector3.zero;
                                }
                            }
                        }
                    }
                    //empty slot
                    else
                    {
                        if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
                        {
                            firstItemGameObject.transform.SetParent(oldSlot.transform);
                            firstItemRectTransform.localPosition = Vector3.zero;
                        }
                        else
                        {
                            firstItemGameObject.transform.SetParent(newSlot.transform);
                            firstItemRectTransform.localPosition = Vector3.zero;

                            if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
                            {
                                oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
                            }
                            createDuplication(firstItemGameObject);
                        }
                    }
                }


                //dragging into a equipmentsystem/charactersystem
                if (Inventory.GetComponent <EquipmentSystem>() != null)
                {
                    ItemType[] itemTypeOfSlots   = GameObject.FindGameObjectWithTag("EquipmentSystem").GetComponent <EquipmentSystem>().itemTypeOfSlots;
                    int        newSlotChildCount = newSlot.transform.parent.childCount;
                    bool       isOnSlot          = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
                    bool       sameItemType      = firstItem.itemType == secondItem.itemType;
                    bool       fromHot           = oldSlot.transform.parent.parent.GetComponent <Hotbar>() != null;

                    //dragging on a slot where allready is an item on
                    if (newSlotChildCount != 0 && isOnSlot)
                    {
                        //items getting swapped if they are the same itemtype
                        if (sameItemType && !sameItemRerferenced) //
                        {
                            Transform temp1 = secondItemGameObject.transform.parent.parent.parent;
                            Transform temp2 = oldSlot.transform.parent.parent;

                            firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                            secondItemGameObject.transform.SetParent(oldSlot.transform);
                            secondItemRectTransform.localPosition = Vector3.zero;
                            firstItemRectTransform.localPosition  = Vector3.zero;

                            if (!temp1.Equals(temp2))
                            {
                                if (firstItem.itemType == ItemType.UFPS_Weapon)
                                {
                                    Inventory.GetComponent <Inventory>().UnEquipItem1(secondItem);
                                    Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
                                }
                                else
                                {
                                    Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
                                    if (secondItem.itemType != ItemType.Backpack)
                                    {
                                        Inventory.GetComponent <Inventory>().UnEquipItem1(secondItem);
                                    }
                                }
                            }

                            if (fromHot)
                            {
                                createDuplication(secondItemGameObject);
                            }
                        }
                        //if they are not from the same Itemtype the dragged one getting placed back
                        else
                        {
                            firstItemGameObject.transform.SetParent(oldSlot.transform);
                            firstItemRectTransform.localPosition = Vector3.zero;

                            if (fromHot)
                            {
                                createDuplication(firstItemGameObject);
                            }
                        }
                    }
                    //if the slot is empty
                    else
                    {
                        for (int i = 0; i < newSlot.parent.childCount; i++)
                        {
                            if (newSlot.Equals(newSlot.parent.GetChild(i)))
                            {
                                //checking if it is the right slot for the item
                                if (itemTypeOfSlots[i] == transform.GetComponent <ItemOnObject>().item.itemType)
                                {
                                    transform.SetParent(newSlot);
                                    rectTransform.localPosition = Vector3.zero;

                                    if (!oldSlot.transform.parent.parent.Equals(newSlot.transform.parent.parent))
                                    {
                                        Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
                                    }
                                }
                                //else it get back to the old slot
                                else
                                {
                                    transform.SetParent(oldSlot.transform);
                                    rectTransform.localPosition = Vector3.zero;
                                    if (fromHot)
                                    {
                                        createDuplication(firstItemGameObject);
                                    }
                                }
                            }
                        }
                    }
                }

                if (Inventory.GetComponent <CraftSystem>() != null)
                {
                    CraftSystem cS = Inventory.GetComponent <CraftSystem>();
                    int         newSlotChildCount = newSlot.transform.parent.childCount;


                    bool isOnSlot = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
                    //dragging on a slot where allready is an item on
                    if (newSlotChildCount != 0 && isOnSlot)
                    {
                        //check if the items fits into the other item
                        bool fitsIntoStack = false;
                        if (sameItem)
                        {
                            fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
                        }
                        //if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items

                        if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
                        {
                            //if the item does not fit into the other item
                            if (fitsIntoStack && !sameItemRerferenced)
                            {
                                secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
                                secondItemGameObject.transform.SetParent(newSlot.parent.parent);
                                Destroy(firstItemGameObject);
                                secondItemRectTransform.localPosition = Vector3.zero;


                                if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
                                {
                                    GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
                                    dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
                                    dup.GetComponent <SplitItem>().inv.stackableSettings();
                                    dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
                                }
                                cS.ListWithItem();
                            }

                            else
                            {
                                //creates the rest of the item
                                int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;

                                //fill up the other stack and adds the rest to the other stack
                                if (!fitsIntoStack && rest > 0)
                                {
                                    firstItem.itemValue  = firstItem.maxStack;
                                    secondItem.itemValue = rest;

                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);

                                    firstItemRectTransform.localPosition  = Vector3.zero;
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                    cS.ListWithItem();
                                }
                            }
                        }
                        //if does not fit
                        else
                        {
                            //creates the rest of the item
                            int rest = 0;
                            if (sameItem)
                            {
                                rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
                            }

                            //fill up the other stack and adds the rest to the other stack
                            if (!fitsIntoStack && rest > 0)
                            {
                                secondItem.itemValue = firstItem.maxStack;
                                firstItem.itemValue  = rest;

                                firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                secondItemGameObject.transform.SetParent(oldSlot.transform);

                                firstItemRectTransform.localPosition  = Vector3.zero;
                                secondItemRectTransform.localPosition = Vector3.zero;
                                cS.ListWithItem();
                            }
                            //if they are different items or the stack is full, they get swapped
                            else if (!fitsIntoStack && rest == 0)
                            {
                                //if you are dragging an item from equipmentsystem to the inventory and try to swap it with the same itemtype
                                if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType == secondItem.itemType)
                                {
                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                    firstItemRectTransform.localPosition  = Vector3.zero;

                                    oldSlot.transform.parent.parent.GetComponent <Inventory>().EquiptItem(secondItem);
                                    newSlot.transform.parent.parent.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
                                }
                                //if you are dragging an item from the equipmentsystem to the inventory and they are not from the same itemtype they do not get swapped.
                                else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType != secondItem.itemType)
                                {
                                    firstItemGameObject.transform.SetParent(oldSlot.transform);
                                    firstItemRectTransform.localPosition = Vector3.zero;
                                }
                                //swapping for the rest of the inventorys
                                else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null)
                                {
                                    firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
                                    secondItemGameObject.transform.SetParent(oldSlot.transform);
                                    secondItemRectTransform.localPosition = Vector3.zero;
                                    firstItemRectTransform.localPosition  = Vector3.zero;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
                        {
                            firstItemGameObject.transform.SetParent(oldSlot.transform);
                            firstItemRectTransform.localPosition = Vector3.zero;
                        }
                        else
                        {
                            firstItemGameObject.transform.SetParent(newSlot.transform);
                            firstItemRectTransform.localPosition = Vector3.zero;

                            if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
                            {
                                oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
                            }
                        }
                    }
                }
            }

            else
            {
                if (GetComponent <ItemOnObject>().item.outbox.tag == "Shop")
                {
                    Item        returitem     = GetComponent <ItemOnObject>().item;
                    Inventory   shopinventory = returitem.outbox.GetComponent <Inventory>();
                    Component[] components    = returitem.outbox.GetComponents <Inventory>();
                    shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);

                    shopinventory.OnUpdateItemList();
                    Destroy(this.gameObject);
                }
                else
                {
                    GameObject dropItem = (GameObject)Instantiate(GetComponent <ItemOnObject>().item.itemModel);
                    dropItem.AddComponent <PickUpItem>();
                    dropItem.GetComponent <PickUpItem>().item = this.gameObject.GetComponent <ItemOnObject>().item;
                    dropItem.transform.localPosition          = GameObject.FindGameObjectWithTag("Player").transform.localPosition;
                    inventory.OnUpdateItemList();
                    if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
                    {
                        inventory.GetComponent <Inventory>().UnEquipItem1(dropItem.GetComponent <PickUpItem>().item);
                    }
                    Destroy(this.gameObject);
                }
            }
        }
        inventory.OnUpdateItemList();
    }
コード例 #7
0
    public void OnPointerDown(PointerEventData data)
    {
        if (this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() == null)
        {
            bool      gearable  = false;
            Inventory inventory = transform.parent.parent.parent.GetComponent <Inventory>();

            if (eS != null)
            {
                itemTypeOfSlot = eS.itemTypeOfSlots;
            }

            if (data.button == PointerEventData.InputButton.Left && DoubleClick() && item.itemType == ItemType.Consumable)     // if we doubleClick with the mouse's left button
            {
                //item from craft system to inventory
                if (transform.parent.GetComponent <CraftResultSlot>() != null)
                {
                    bool check = inv.GetComponent <Inventory>().checkIfItemAllreadyExist(item.itemID, item.itemValue);

                    if (!check)
                    {
                        for (int j = 0; j < inv.transform.GetChild(1).transform.childCount; j++)
                        {
                            if (inv.transform.GetChild(1).transform.GetChild(j).childCount != 0)
                            {
                                //if the item we're crafting has a slot filled in the main inventory and there are some places
                                if (item.itemID.Equals(inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.itemID) && inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.itemValue != inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.maxStack)
                                {
                                    //filling the remaining places before adding the rest through the normal add
                                    if (inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.itemValue + item.itemValue > inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.maxStack)
                                    {
                                        item.itemValue -= (inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.maxStack - inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.itemValue);
                                        inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.itemValue = inv.transform.GetChild(1).transform.GetChild(j).GetChild(0).GetComponent <ItemOnObject>().item.maxStack;
                                    }
                                }
                            }
                        }
                        //normal add
                        numberOfItems = item.itemValue / item.maxStack;
                        for (int i = 0; i < numberOfItems; i++)
                        {
                            inv.GetComponent <Inventory>().addItemToInventory(item.itemID, item.maxStack);
                            inv.GetComponent <Inventory>().stackableSettings();
                        }
                        if (item.itemValue % item.maxStack != 0)
                        {
                            inv.GetComponent <Inventory>().addItemToInventory(item.itemID, item.itemValue % item.maxStack);
                            inv.GetComponent <Inventory>().stackableSettings();
                        }
                    }
                    CraftSystem cS = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().craftSystem.GetComponent <CraftSystem>();
                    cS.deleteItems(item);
                    CraftResultSlot result = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerInventory>().craftSystem.transform.GetChild(3).GetComponent <CraftResultSlot>();
                    tooltip.deactivateTooltip();
                    gearable = true;
                    inv.GetComponent <Inventory>().updateItemList();
                }
                else
                {
                    bool stop = false;
                    if (eS != null)
                    {
                        for (int i = 0; i < eS.slotsInTotal; i++)
                        {
                            if (itemTypeOfSlot[i].Equals(item.itemType))
                            {
                                if (eS.transform.GetChild(1).GetChild(i).childCount == 0)
                                {
                                    stop = true;
                                    if (eS.transform.GetChild(1).GetChild(i).parent.parent.GetComponent <EquipmentSystem>() != null && this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() != null)
                                    {
                                    }
                                    else
                                    {
                                        inventory.EquiptItem(item);
                                    }

                                    this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                                    this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                    eS.gameObject.GetComponent <Inventory>().updateItemList();
                                    inventory.updateItemList();
                                    gearable = true;
                                    if (duplication != null)
                                    {
                                        Destroy(duplication.gameObject);
                                    }
                                    break;
                                }
                            }
                        }

                        if (!stop)
                        {
                            for (int i = 0; i < eS.slotsInTotal; i++)
                            {
                                if (itemTypeOfSlot[i].Equals(item.itemType))
                                {
                                    if (eS.transform.GetChild(1).GetChild(i).childCount != 0)
                                    {
                                        GameObject otherItemFromCharacterSystem = eS.transform.GetChild(1).GetChild(i).GetChild(0).gameObject;
                                        Item       otherSlotItem = otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item;
                                        if (item.itemType == ItemType.UFPS_Weapon)
                                        {
                                            inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                            inventory.EquiptItem(item);
                                        }
                                        else
                                        {
                                            inventory.EquiptItem(item);
                                            if (item.itemType != ItemType.Backpack)
                                            {
                                                inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
                                            }
                                        }
                                        if (this == null)
                                        {
                                            GameObject dropItem = (GameObject)Instantiate(otherSlotItem.itemModel);
                                            dropItem.AddComponent <PickUpItem>();
                                            dropItem.GetComponent <PickUpItem>().item = otherSlotItem;
                                            dropItem.transform.localPosition          = GameObject.FindGameObjectWithTag("Player").transform.localPosition;
                                            inventory.OnUpdateItemList();
                                        }
                                        else
                                        {
                                            otherItemFromCharacterSystem.transform.SetParent(this.transform.parent);
                                            otherItemFromCharacterSystem.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                            if (this.gameObject.transform.parent.parent.parent.GetComponent <Hotbar>() != null)
                                            {
                                                createDuplication(otherItemFromCharacterSystem);
                                            }

                                            this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
                                            this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
                                        }

                                        gearable = true;
                                        if (duplication != null)
                                        {
                                            Destroy(duplication.gameObject);
                                        }
                                        eS.gameObject.GetComponent <Inventory>().updateItemList();
                                        inventory.OnUpdateItemList();
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                if (!gearable && item.itemType != ItemType.UFPS_Ammo && item.itemType != ItemType.UFPS_Grenade)
                {
                    Item itemFromDup = null;
                    if (duplication != null)
                    {
                        itemFromDup = duplication.GetComponent <ItemOnObject>().item;
                    }

                    inventory.ConsumeItem(item);

                    item.itemValue--;
                    if (itemFromDup != null)
                    {
                        duplication.GetComponent <ItemOnObject>().item.itemValue--;
                        if (itemFromDup.itemValue <= 0)
                        {
                            if (tooltip != null)
                            {
                                tooltip.deactivateTooltip();
                            }
                            inventory.deleteItemFromInventory(item);
                            Destroy(duplication.gameObject);
                        }
                    }
                    if (item.itemValue <= 0)
                    {
                        if (tooltip != null)
                        {
                            tooltip.deactivateTooltip();
                        }
                        inventory.deleteItemFromInventory(item);
                        Destroy(this.gameObject);
                    }
                }
            }
        }
    }