Esempio n. 1
0
    void Update()
    {
        Player player = Player.localPlayer;

        if (player)
        {
            // hotkey (not while typing in chat, etc.)
            if (Input.GetKeyDown(hotKey) && !UIUtils.AnyInputActive())
            {
                panel.SetActive(!panel.activeSelf);
            }

            // only update the panel if it's active
            if (panel.activeSelf)
            {
                // instantiate/destroy enough slots
                UIUtils.BalancePrefabs(slotPrefab.gameObject, player.equipment.Count, content);

                // refresh all
                for (int i = 0; i < player.equipment.Count; ++i)
                {
                    UIEquipmentSlot slot = content.GetChild(i).GetComponent <UIEquipmentSlot>();
                    slot.dragAndDropable.name = i.ToString(); // drag and drop slot
                    ItemSlot itemSlot = player.equipment[i];

                    // set category overlay in any case. we use the last noun in the
                    // category string, for example EquipmentWeaponBow => Bow
                    // (disabled if no category, e.g. for archer shield slot)
                    slot.categoryOverlay.SetActive(player.equipmentInfo[i].requiredCategory != "");
                    string overlay = Utils.ParseLastNoun(player.equipmentInfo[i].requiredCategory);
                    slot.categoryText.text = overlay != "" ? overlay : "?";

                    if (itemSlot.amount > 0)
                    {
                        // refresh valid item
                        slot.tooltip.enabled          = true;
                        slot.tooltip.text             = itemSlot.ToolTip();
                        slot.dragAndDropable.dragable = true;
                        slot.image.color  = Color.white;
                        slot.image.sprite = itemSlot.item.image;
                        slot.amountOverlay.SetActive(itemSlot.amount > 1);
                        slot.amountText.text = itemSlot.amount.ToString();
                    }
                    else
                    {
                        // refresh invalid item
                        slot.tooltip.enabled          = false;
                        slot.dragAndDropable.dragable = false;
                        slot.image.color  = Color.clear;
                        slot.image.sprite = null;
                        slot.amountOverlay.SetActive(false);
                    }
                }
            }
        }
        else
        {
            panel.SetActive(false);
        }
    }
    // Adds a listener to the equipment item button to allow click removal.
    private void RemoveEquipmentItem(int currentIndex, UIEquipmentSlot slot, Player player)
    {
#if _iMMOITEMRARITY
        Button button = slot.transform.GetChild(1).GetComponent <Button>();
#else
        Button button = slot.transform.GetChild(0).GetComponent <Button>();
#endif
        button.onClick.SetListener(() =>
        {
            player.CmdRemoveEquipmentItem(currentIndex); // added to move equipment into open inventory slot
        });
    }
Esempio n. 3
0
    void Update()
    {
        GameObject player = Player.player;

        if (!player)
        {
            return;
        }
        PlayerEquipment equipment = player.GetComponent <PlayerEquipment>();

        // instantiate/destroy enough slots
        UIUtils.BalancePrefabs(slotPrefab.gameObject, equipment.slots.Count, content);

        // refresh all
        for (int i = 0; i < equipment.slots.Count; ++i)
        {
            UIEquipmentSlot slot = content.GetChild(i).GetComponent <UIEquipmentSlot>();
            slot.dragAndDropable.name = i.ToString(); // drag and drop slot
            ItemSlot itemSlot = equipment.slots[i];

            // set category overlay in any case. we use the last noun in the
            // category string, for example EquipmentWeaponBow => Bow
            // (disabled if no category, e.g. for archer shield slot)
            slot.categoryOverlay.SetActive(equipment.slotInfo[i].requiredCategory != "");
            string overlay = equipment.slotInfo[i].requiredCategory;
            slot.categoryText.text = overlay != "" ? overlay : "?";

            if (itemSlot.amount > 0)
            {
                // refresh valid item
                slot.tooltip.enabled          = true;
                slot.tooltip.text             = itemSlot.ToolTip();
                slot.dragAndDropable.dragable = true;
                slot.image.color  = Color.white;
                slot.image.sprite = itemSlot.item.image;
                slot.amountOverlay.SetActive(itemSlot.amount > 1);
                slot.amountText.text = itemSlot.amount.ToString();
            }
            else
            {
                // refresh invalid item
                slot.tooltip.enabled          = false;
                slot.dragAndDropable.dragable = false;
                slot.image.color  = Color.clear;
                slot.image.sprite = null;
                slot.amountOverlay.SetActive(false);
            }
        }
    }
    // Assign our componenet based on the slot type.
    private void LateUpdate()
    {
        player = Player.localPlayer;

        if (player != null)
        {
            switch (slotType)
            {
            case SlotType.Equipment:
                // refresh all
                int lastECount = 0;
                if (lastECount != player.equipment.Count)
                {
                    for (int i = 0; i < player.equipment.Count; ++i)
                    {
                        lastECount = player.equipment.Count;
                        if (player.equipment[i].amount > 0)
                        {
                            UIEquipment equipmentContents = gameObject.GetComponent <UIEquipment>();
                            UIUtils.BalancePrefabs(equipmentContents.slotPrefab.gameObject, player.equipment.Count, equipmentContents.content);
                            if (equipmentContents.panel.activeSelf)
                            {
                                UIEquipmentSlot slot = equipmentContents.content.transform.GetChild(i).GetComponent <UIEquipmentSlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                tooltip    = slot.tooltip;
                                slot.dragAndDropable.name = i.ToString();     // drag and drop slot
                                itemSlot = player.equipment[i];
                                SetRarityColor(itemSlot.item.data);
                            }
                        }
                        else
                        {
                            UIEquipment equipmentContents = gameObject.GetComponent <UIEquipment>();
                            if (equipmentContents.panel.activeSelf)
                            {
                                UIEquipmentSlot slot = equipmentContents.content.transform.GetChild(i).GetComponent <UIEquipmentSlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                raritySlot.rarityOutline.color = Color.clear;
                            }
                        }
                    }
                }
                break;

            case SlotType.Inventory:
                // refresh all
                int lastICount = 0;
                if (lastICount != player.inventory.Count)
                {
                    for (int i = 0; i < player.inventory.Count; ++i)
                    {
                        lastICount = player.inventory.Count;
                        if (player.inventory[i].amount > 0)
                        {
                            UIInventory inventoryContents = GetComponent <UIInventory>();
                            UIUtils.BalancePrefabs(inventoryContents.slotPrefab.gameObject, player.inventory.Count, inventoryContents.content);
                            if (inventoryContents.panel.activeSelf)
                            {
                                UIInventorySlot slot = inventoryContents.content.transform.GetChild(i).GetComponent <UIInventorySlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                tooltip    = slot.tooltip;
                                slot.dragAndDropable.name = i.ToString();     // drag and drop slot
                                itemSlot = player.inventory[i];
                                SetRarityColor(itemSlot.item.data);
                            }
                        }
                        else
                        {
                            UIInventory inventoryContents = gameObject.GetComponent <UIInventory>();
                            if (inventoryContents.panel.activeSelf)
                            {
                                UIInventorySlot slot = inventoryContents.content.transform.GetChild(i).GetComponent <UIInventorySlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                raritySlot.rarityOutline.color = Color.clear;
                            }
                        }
                    }
                }
                break;

            case SlotType.Loot:
                if (player.target != null && player.target.health <= 0)
                {
                    UILoot          lootContent = GetComponent <UILoot>();
                    List <ItemSlot> items       = player.target.inventory.Where(slot => slot.amount > 0).ToList();
                    UIUtils.BalancePrefabs(lootContent.itemSlotPrefab.gameObject, items.Count, lootContent.content);

                    // refresh all valid items
                    for (int i = 0; i < items.Count; ++i)
                    {
                        UILootSlot slot = lootContent.content.GetChild(i).GetComponent <UILootSlot>();
                        slot.dragAndDropable.name = i.ToString();     // drag and drop index
                        int itemIndex = player.target.inventory.FindIndex(
                            // note: .Equals because name AND dynamic variables matter (petLevel etc.)
                            itemSlot => itemSlot.amount > 0 && itemSlot.item.Equals(items[i].item)
                            );

                        // refresh
                        raritySlot = slot.GetComponent <UCE_RaritySlot>();
                        tooltip    = slot.tooltip;
                        slot.dragAndDropable.name = i.ToString();     // drag and drop slot
                        itemSlot = items[i];
                        SetRarityColor(itemSlot.item.data);
                    }
                }
                break;

            case SlotType.PlayerTrade:
                if (player.state == "TRADING")
                {
                    Player other        = (Player)player.target;
                    int    lastPTYCount = 0;
                    if (lastPTYCount != player.tradeOfferItems.Count)
                    {
                        for (int i = 0; i < player.tradeOfferItems.Count; ++i)
                        {
                            lastPTYCount = player.tradeOfferItems.Count;
                            UIPlayerTrading tradeContents = GetComponent <UIPlayerTrading>();
                            UIUtils.BalancePrefabs(tradeContents.slotPrefab.gameObject, player.tradeOfferItems.Count, tradeContents.myContent);
                            if (tradeContents.panel.activeSelf)
                            {
                                UIPlayerTradingSlot slot = tradeContents.myContent.transform.GetChild(i).GetComponent <UIPlayerTradingSlot>();
                                if (slot.amountText.text != "0")
                                {
                                    raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                    tooltip    = slot.tooltip;
                                    slot.dragAndDropable.name = i.ToString();     // drag and drop slot
                                    int inventoryIndex = player.tradeOfferItems[i];
                                    itemSlot = player.inventory[inventoryIndex];
                                    SetRarityColor(itemSlot.item.data);
                                }
                                else
                                {
                                    raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                    raritySlot.rarityOutline.color = Color.clear;
                                }
                            }
                        }
                    }

                    int lastPTOCount = 0;
                    if (lastPTOCount != other.tradeOfferItems.Count)
                    {
                        for (int i = 0; i < other.tradeOfferItems.Count; ++i)
                        {
                            lastPTOCount = other.tradeOfferItems.Count;
                            UIPlayerTrading tradeContents = GetComponent <UIPlayerTrading>();
                            UIUtils.BalancePrefabs(tradeContents.slotPrefab.gameObject, other.tradeOfferItems.Count, tradeContents.otherContent);
                            if (tradeContents.panel.activeSelf)
                            {
                                UIPlayerTradingSlot slot = tradeContents.otherContent.transform.GetChild(i).GetComponent <UIPlayerTradingSlot>();
                                if (slot.amountText.text != "0")
                                {
                                    raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                    tooltip    = slot.tooltip;
                                    slot.dragAndDropable.name = i.ToString();     // drag and drop slot
                                    int inventoryIndex = other.tradeOfferItems[i];
                                    itemSlot = other.inventory[inventoryIndex];
                                    SetRarityColor(itemSlot.item.data);
                                }
                                else
                                {
                                    raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                    raritySlot.rarityOutline.color = Color.clear;
                                }
                            }
                        }
                    }
                }
                break;

            case SlotType.NpcTrade:
                if (player.target is Npc)
                {
                    Npc npc = (Npc)player.target;
#if _iMMONPCSHOP
                    UCE_UI_NpcShop shopContents = GetComponent <UCE_UI_NpcShop>();
                    if (shopContents.panel.activeSelf)
                    {
                        ScriptableItem[] items = npc.saleItems.Where(x => x.itemCategory == shopContents.currentCategory || shopContents.currentCategory == "").ToArray();
                        UIUtils.BalancePrefabs(shopContents.itemSlotPrefab.gameObject, items.Length, shopContents.itemContent);

                        int    lastIMCount = 0;
                        string currentPage = "";
                        if (lastIMCount != items.Length || currentPage != shopContents.currentCategory)
                        {
                            for (int i = 0; i < items.Length; ++i)
                            {
                                lastIMCount = items.Length;
                                currentPage = shopContents.currentCategory;

                                UCE_UI_NpcShopSlot slot = shopContents.itemContent.GetChild(i).GetComponent <UCE_UI_NpcShopSlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                tooltip    = slot.tooltip;
                                scriptItem = items[i];
                                SetRarityColor(scriptItem);
                            }
                        }
                    }
#else
                    int lastNTCount = 0;
                    if (lastNTCount != npc.saleItems.Length)
                    {
                        for (int i = 0; i < npc.saleItems.Length; ++i)
                        {
                            lastNTCount = npc.saleItems.Length;
                            UINpcTrading npcContents = GetComponent <UINpcTrading>();
                            UIUtils.BalancePrefabs(npcContents.slotPrefab.gameObject, npc.saleItems.Length, npcContents.content);
                            if (npcContents.panel.activeSelf)
                            {
                                UINpcTradingSlot slot = npcContents.content.transform.GetChild(i).GetComponent <UINpcTradingSlot>();
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                tooltip    = slot.tooltip;
                                scriptItem = npc.saleItems[i];
                                SetRarityColor(scriptItem);
                            }
                        }
                    }
#endif
                }
                break;

            case SlotType.ItemMall:
                UIItemMall mallContents = GetComponent <UIItemMall>();
                if (mallContents.panel.activeSelf)
                {
                    ScriptableItem[] items = player.itemMallCategories[mallContents.currentCategory].items;
                    UIUtils.BalancePrefabs(mallContents.itemSlotPrefab.gameObject, items.Length, mallContents.itemContent);

                    int lastIMCount = 0;
                    int currentPage = 0;
                    if (lastIMCount != items.Length || currentPage != mallContents.currentCategory)
                    {
                        for (int i = 0; i < items.Length; ++i)
                        {
                            lastIMCount = items.Length;
                            currentPage = mallContents.currentCategory;
                            UIItemMallSlot slot = mallContents.itemContent.GetChild(i).GetComponent <UIItemMallSlot>();
                            raritySlot = slot.GetComponent <UCE_RaritySlot>();
                            tooltip    = slot.tooltip;
                            scriptItem = items[i];
                            SetRarityColor(scriptItem);
                        }
                    }
                }
                break;

            case SlotType.Crafting:
                UICrafting craftContents = GetComponent <UICrafting>();
                UIUtils.BalancePrefabs(craftContents.ingredientSlotPrefab.gameObject, player.craftingIndices.Count, craftContents.ingredientContent);
                if (craftContents.panel.activeSelf)
                {
                    int lastCCount = 0;
                    if (lastCCount != player.craftingIndices.Count)
                    {
                        for (int i = 0; i < player.craftingIndices.Count; ++i)
                        {
                            lastCCount = player.craftingIndices.Count;
                            UICraftingIngredientSlot slot = craftContents.ingredientContent.GetChild(i).GetComponent <UICraftingIngredientSlot>();
                            if (player.craftingIndices[i] != -1)
                            {
                                int itemIndex = player.craftingIndices[i];
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                tooltip    = slot.tooltip;
                                itemSlot   = player.inventory[itemIndex];
                                SetRarityColor(itemSlot.item.data);
                            }
                            else
                            {
                                raritySlot = slot.GetComponent <UCE_RaritySlot>();
                                raritySlot.rarityOutline.color = Color.clear;
                            }
                        }
                    }
                }
                break;
            }
        }
    }
Esempio n. 5
0
    void Update()
    {
        Player player = Player.localPlayer;

        if (player)
        {
            // hotkey (not while typing in chat, etc.)
            if (Input.GetKeyDown(hotKey) && !UIUtils.AnyInputActive())
            {
                panel.SetActive(!panel.activeSelf);
            }

            // only update the panel if it's active
            if (panel.activeSelf)
            {
                // instantiate/destroy enough slots
                UIUtils.BalancePrefabs(slotPrefab.gameObject, player.equipment.slots.Count, content);

                // refresh all
                for (int i = 0; i < player.equipment.slots.Count; ++i)
                {
                    UIEquipmentSlot slot = content.GetChild(i).GetComponent <UIEquipmentSlot>();
                    slot.dragAndDropable.name = i.ToString(); // drag and drop slot
                    ItemSlot itemSlot = player.equipment.slots[i];

                    // set category overlay in any case. we use the last noun in the
                    // category string, for example EquipmentWeaponBow => Bow
                    // (disabled if no category, e.g. for archer shield slot)
                    EquipmentInfo slotInfo = ((PlayerEquipment)player.equipment).slotInfo[i];
                    slot.categoryOverlay.SetActive(slotInfo.requiredCategory != "");
                    string overlay = Utils.ParseLastNoun(slotInfo.requiredCategory);
                    slot.categoryText.text = overlay != "" ? overlay : "?";

                    if (itemSlot.amount > 0)
                    {
                        // refresh valid item

                        // only build tooltip while it's actually shown. this
                        // avoids MASSIVE amounts of StringBuilder allocations.
                        slot.tooltip.enabled = true;
                        if (slot.tooltip.IsVisible())
                        {
                            slot.tooltip.text = itemSlot.ToolTip();
                        }
                        slot.dragAndDropable.dragable = true;

                        // use durability colors?
                        if (itemSlot.item.maxDurability > 0)
                        {
                            if (itemSlot.item.durability == 0)
                            {
                                slot.image.color = brokenDurabilityColor;
                            }
                            else if (itemSlot.item.DurabilityPercent() < lowDurabilityThreshold)
                            {
                                slot.image.color = lowDurabilityColor;
                            }
                            else
                            {
                                slot.image.color = Color.white;
                            }
                        }
                        else
                        {
                            slot.image.color = Color.white;  // reset for no-durability items
                        }
                        slot.image.sprite = itemSlot.item.image;

                        // cooldown if usable item
                        if (itemSlot.item.data is UsableItem usable)
                        {
                            float cooldown = player.GetItemCooldown(usable.cooldownCategory);
                            slot.cooldownCircle.fillAmount = usable.cooldown > 0 ? cooldown / usable.cooldown : 0;
                        }
                        else
                        {
                            slot.cooldownCircle.fillAmount = 0;
                        }
                        slot.amountOverlay.SetActive(itemSlot.amount > 1);
                        slot.amountText.text = itemSlot.amount.ToString();
                    }
                    else
                    {
                        // refresh invalid item
                        slot.tooltip.enabled          = false;
                        slot.dragAndDropable.dragable = false;
                        slot.image.color  = Color.clear;
                        slot.image.sprite = null;
                        slot.cooldownCircle.fillAmount = 0;
                        slot.amountOverlay.SetActive(false);
                    }
                }
            }
        }
        else
        {
            panel.SetActive(false);
        }
    }
Esempio n. 6
0
    void Update()
    {
        Player player = Player.localPlayer;

        if (player)
        {
            UIUtils.BalancePrefabs(slotPrefab.gameObject, player.equipment.slots.Count, content);
            for (int i = 0; i < player.equipment.slots.Count; ++i)
            {
                UIEquipmentSlot slot = content.GetChild(i).GetComponent <UIEquipmentSlot>();
                slot.dragAndDropable.name = i.ToString();
                ItemSlot itemSlot = player.equipment.slots[i];
                slot.categoryOverlay.SetActive(player.equipment.slotInfo[i].requiredCategory != "");
                string overlay = Utils.ParseLastNoun(player.equipment.slotInfo[i].requiredCategory);
                slot.categoryText.text = overlay != "" ? overlay : "?";
                if (itemSlot.amount > 0)
                {
                    slot.tooltip.enabled = true;
                    if (slot.tooltip.IsVisible())
                    {
                        slot.tooltip.text = itemSlot.ToolTip();
                    }
                    slot.dragAndDropable.dragable = true;
                    if (itemSlot.item.maxDurability > 0)
                    {
                        if (itemSlot.item.durability == 0)
                        {
                            slot.image.color = brokenDurabilityColor;
                        }
                        else if (itemSlot.item.DurabilityPercent() < lowDurabilityThreshold)
                        {
                            slot.image.color = lowDurabilityColor;
                        }
                        else
                        {
                            slot.image.color = Color.white;
                        }
                    }
                    else
                    {
                        slot.image.color = Color.white;
                    }
                    slot.image.sprite = itemSlot.item.image;
                    if (itemSlot.item.data is UsableItem usable)
                    {
                        float cooldown = player.GetItemCooldown(usable.cooldownCategory);
                        slot.cooldownCircle.fillAmount = usable.cooldown > 0 ? cooldown / usable.cooldown : 0;
                    }
                    else
                    {
                        slot.cooldownCircle.fillAmount = 0;
                    }
                    slot.amountOverlay.SetActive(itemSlot.amount > 1);
                    slot.amountText.text = itemSlot.amount.ToString();
                }
                else
                {
                    slot.tooltip.enabled          = false;
                    slot.dragAndDropable.dragable = false;
                    slot.image.color  = Color.clear;
                    slot.image.sprite = null;
                    slot.cooldownCircle.fillAmount = 0;
                    slot.amountOverlay.SetActive(false);
                }
            }
        }
    }