protected override void SetupInventoryTypeToggole()
    {
        SmithManager.SmithCreateData smithData = MonoBehaviourSingleton <SmithManager> .I.GetSmithData <SmithManager.SmithCreateData>();

        SortBase.TYPE selectCreateEquipItemType = smithData.selectCreateEquipItemType;
        bool          flag = false;

        if (selectCreateEquipItemType < SortBase.TYPE.ARMOR || selectCreateEquipItemType == SortBase.TYPE.WEAPON_ALL)
        {
            flag = true;
        }
        SetActive((Enum)UI.OBJ_ATK_ROOT, flag);
        SetActive((Enum)UI.OBJ_DEF_ROOT, !flag);
        SetToggleButton((Enum)UI.TGL_BUTTON_ROOT, flag, (Action <bool>) delegate(bool is_active)
        {
            SmithManager.SmithCreateData smithData2 = MonoBehaviourSingleton <SmithManager> .I.GetSmithData <SmithManager.SmithCreateData>();
            smithData2.selectCreateEquipItemType    = (is_active ? SortBase.TYPE.ONE_HAND_SWORD : SortBase.TYPE.HELM);
            int num = (!is_active) ? 1 : 0;
            ResetTween((Enum)tabAnimTarget[num], 0);
            PlayTween((Enum)tabAnimTarget[num], true, (EventDelegate.Callback)null, false, 0);
            SetActive((Enum)UI.OBJ_ATK_ROOT, is_active);
            SetActive((Enum)UI.OBJ_DEF_ROOT, !is_active);
            selectTypeIndex = (int)Mathf.Log((float)smithData2.selectCreateEquipItemType, 2f);
            SetDirty(InventoryUI);
            InitSort();
            InitLocalInventory();
            LocalInventory();
            UpdateTabButton();
            if (!TutorialStep.HasAllTutorialCompleted() && smithData2.selectCreateEquipItemType == SortBase.TYPE.HELM)
            {
                MonoBehaviourSingleton <UIManager> .I.tutorialMessage.ForceRun(MonoBehaviourSingleton <GameSceneManager> .I.GetCurrentSceneName(), "SelectArmor", null);
            }
        });
    }
Beispiel #2
0
    public EQUIPMENT_TYPE SortBaseTypeToEquipmentType(SortBase.TYPE type)
    {
        switch (type)
        {
        default:
            return(EQUIPMENT_TYPE.ONE_HAND_SWORD);

        case SortBase.TYPE.ONE_HAND_SWORD:
            return(EQUIPMENT_TYPE.ONE_HAND_SWORD);

        case SortBase.TYPE.TWO_HAND_SWORD:
            return(EQUIPMENT_TYPE.TWO_HAND_SWORD);

        case SortBase.TYPE.SPEAR:
            return(EQUIPMENT_TYPE.SPEAR);

        case SortBase.TYPE.PAIR_SWORDS:
            return(EQUIPMENT_TYPE.PAIR_SWORDS);

        case SortBase.TYPE.ARROW:
            return(EQUIPMENT_TYPE.ARROW);

        case SortBase.TYPE.ARMOR:
            return(EQUIPMENT_TYPE.ARMOR);

        case SortBase.TYPE.HELM:
            return(EQUIPMENT_TYPE.HELM);

        case SortBase.TYPE.ARM:
            return(EQUIPMENT_TYPE.ARM);

        case SortBase.TYPE.LEG:
            return(EQUIPMENT_TYPE.LEG);
        }
    }
Beispiel #3
0
 public override void ResetData()
 {
     selectCreateEquipItemType = SortBase.TYPE.ONE_HAND_SWORD;
     selectEquipData           = null;
     generateTableData         = null;
     createEquipItemTable      = null;
     base.ResetData();
 }
    private void RemoveCreateNewIcon(int tab_index)
    {
        EQUIPMENT_TYPE type     = TranslateInventoryTypeForEquipment(tab_index);
        int            badgeNum = MonoBehaviourSingleton <SmithManager> .I.smithBadgeData.GetBadgeNum(type);

        if (badgeNum > 0)
        {
            SortBase.TYPE tYPE      = TranslateInventoryType(tab_index);
            bool          is_pickup = tYPE == SortBase.TYPE.WEAPON_ALL || tYPE == SortBase.TYPE.ARMOR_ALL;
            MonoBehaviourSingleton <SmithManager> .I.RemoveSmithBadge(type, is_pickup);

            MonoBehaviourSingleton <SmithManager> .I.CreateBadgeData(true);

            MonoBehaviourSingleton <GameSceneManager> .I.SetNotify(NOTIFY_FLAG.UPDATE_SMITH_BADGE);
        }
    }
    protected override void OnQuery_TYPE_TAB()
    {
        int selectTypeIndex = base.selectTypeIndex;

        base.selectTypeIndex = (int)GameSection.GetEventData();
        RemoveCreateNewIcon(selectTypeIndex);
        SmithManager.SmithCreateData smithData = MonoBehaviourSingleton <SmithManager> .I.GetSmithData <SmithManager.SmithCreateData>();

        SortBase.TYPE tYPE = smithData.selectCreateEquipItemType = TranslateInventoryType(base.selectTypeIndex);
        Debug.Log((object)("old_type_index:" + selectTypeIndex));
        Debug.Log((object)("selectTypeIndex:" + base.selectTypeIndex));
        if ((selectTypeIndex >= 9 && base.selectTypeIndex < 9) || (selectTypeIndex < 9 && base.selectTypeIndex >= 9))
        {
            InitSort();
        }
        SetDirty(InventoryUI);
        InitLocalInventory();
        RefreshUI();
    }
    protected override void InitLocalInventory()
    {
        SmithManager.SmithCreateData smithData = MonoBehaviourSingleton <SmithManager> .I.GetSmithData <SmithManager.SmithCreateData>();

        SortBase.TYPE selectCreateEquipItemType = smithData.selectCreateEquipItemType;
        switch (selectCreateEquipItemType)
        {
        case SortBase.TYPE.WEAPON_ALL:
            localInventoryEquipData = SortCompareData.CreateSortDataAry <SmithCreateItemInfo, SmithCreateSortData>(pickupWeapon, sortSettings, null);
            break;

        case SortBase.TYPE.ARMOR_ALL:
            localInventoryEquipData = SortCompareData.CreateSortDataAry <SmithCreateItemInfo, SmithCreateSortData>(pickupArmor, sortSettings, null);
            break;

        default:
            localInventoryEquipData = sortSettings.CreateSortAry <SmithCreateItemInfo, SmithCreateSortData>(Singleton <CreateEquipItemTable> .I.GetCreateEquipItemDataAry(SortBaseTypeToEquipmentType(selectCreateEquipItemType)));
            break;
        }
        SelectingInventoryFirst();
    }
 protected override void LocalInventory()
 {
     SetupEnableInventoryUI();
     SetLabelText((Enum)UI.LBL_SORT, sortSettings.GetSortLabel());
     if (localInventoryEquipData != null)
     {
         SortBase.TYPE tYPE       = TranslateInventoryType(selectTypeIndex);
         bool          _is_pickup = tYPE == SortBase.TYPE.WEAPON_ALL || tYPE == SortBase.TYPE.ARMOR_ALL;
         SetDynamicList((Enum)InventoryUI, string.Empty, localInventoryEquipData.Length, false, (Func <int, bool>) delegate(int check_index)
         {
             SmithCreateItemInfo smithCreateItemInfo = localInventoryEquipData[check_index].GetItemData() as SmithCreateItemInfo;
             if (smithCreateItemInfo == null)
             {
                 return(false);
             }
             if (!MonoBehaviourSingleton <InventoryManager> .I.IsHaveingKeyMaterial(smithCreateItemInfo.smithCreateTableData.needKeyOrder, smithCreateItemInfo.smithCreateTableData.needMaterial))
             {
                 return(false);
             }
             if ((int)smithCreateItemInfo.smithCreateTableData.researchLv > MonoBehaviourSingleton <UserInfoManager> .I.userStatus.researchLv)
             {
                 return(false);
             }
             if (localInventoryEquipData[check_index].GetTableID() == 0)
             {
                 return(false);
             }
             SortCompareData sortCompareData = localInventoryEquipData[check_index];
             if (sortCompareData == null || !sortCompareData.IsPriority(sortSettings.orderTypeAsc))
             {
                 return(false);
             }
             return(true);
         }, (Func <int, Transform, Transform>) null, (Action <int, Transform, bool>) delegate(int i, Transform t, bool is_recycle)
         {
             SmithCreateItemInfo create_info = localInventoryEquipData[i].GetItemData() as SmithCreateItemInfo;
             uint tableID = localInventoryEquipData[i].GetTableID();
             if (tableID == 0)
             {
                 SetActive(t, false);
             }
             else
             {
                 SetActive(t, true);
                 SmithCreateSortData smithCreateSortData = localInventoryEquipData[i] as SmithCreateSortData;
                 if (smithCreateSortData != null && smithCreateSortData.IsPriority(sortSettings.orderTypeAsc))
                 {
                     EquipItemTable.EquipItemData equipItemData = Singleton <EquipItemTable> .I.GetEquipItemData(tableID);
                     ITEM_ICON_TYPE iconType         = localInventoryEquipData[i].GetIconType();
                     SkillSlotUIData[] skillSlotData = GetSkillSlotData(equipItemData, 0);
                     bool flag         = false;
                     flag              = MonoBehaviourSingleton <SmithManager> .I.NeedSmithBadge(create_info, _is_pickup);
                     ItemIcon itemIcon = CreateSmithCreateItemIconDetail(getType: smithCreateSortData.GetGetType(), icon_type: iconType, icon_id: equipItemData.GetIconID(MonoBehaviourSingleton <UserInfoManager> .I.userStatus.sex), rarity: equipItemData.rarity, item_data: smithCreateSortData, skill_slot_data: skillSlotData, is_show_main_status: base.IsShowMainStatus, parent: t, event_name: "SELECT_ITEM", event_data: i, icon_status: smithCreateSortData.GetIconStatus(), is_new: flag, toggle_group: -1, is_select: false);
                     itemIcon.SetItemID(smithCreateSortData.GetTableID());
                     itemIcon.SetButtonColor(localInventoryEquipData[i].IsPriority(sortSettings.orderTypeAsc), true);
                     SetLongTouch(itemIcon.transform, "DETAIL", i);
                 }
             }
         });
     }
 }
Beispiel #8
0
    public SmithCreateItemInfo[] GetPickupItemAry(SortBase.TYPE item_type = SortBase.TYPE.EQUIP_ALL)
    {
        if (!Singleton <EquipItemTable> .IsValid() || !Singleton <QuestTable> .IsValid())
        {
            return(null);
        }
        List <SmithCreateItemInfo> list      = new List <SmithCreateItemInfo>();
        List <SortData>            sort_data = new List <SortData>();

        pickupTable.ForEach(delegate(CreatePickupItemData pickup_data)
        {
            if ((pickup_data.eventLocationID == 0) ? true : false)
            {
                CreateEquipItemTable.CreateEquipItemData createEquipItemTableData = Singleton <CreateEquipItemTable> .I.GetCreateEquipItemTableData(pickup_data.createTableID);
                if (createEquipItemTableData != null)
                {
                    EquipItemTable.EquipItemData equipItemData = Singleton <EquipItemTable> .I.GetEquipItemData(createEquipItemTableData.equipItemID);
                    if (equipItemData != null)
                    {
                        SmithCreateItemInfo smithCreateItemInfo = new SmithCreateItemInfo(equipItemData, createEquipItemTableData);
                        SortBase.TYPE tYPE = SortBase.TYPE.NONE;
                        switch (smithCreateItemInfo.equipTableData.type)
                        {
                        case EQUIPMENT_TYPE.ARMOR:
                        case EQUIPMENT_TYPE.VISUAL_ARMOR:
                            tYPE = SortBase.TYPE.ARMOR;
                            break;

                        case EQUIPMENT_TYPE.HELM:
                        case EQUIPMENT_TYPE.VISUAL_HELM:
                            tYPE = SortBase.TYPE.HELM;
                            break;

                        case EQUIPMENT_TYPE.ARM:
                        case EQUIPMENT_TYPE.VISUAL_ARM:
                            tYPE = SortBase.TYPE.ARMOR;
                            break;

                        case EQUIPMENT_TYPE.LEG:
                        case EQUIPMENT_TYPE.VISUAL_LEG:
                            tYPE = SortBase.TYPE.LEG;
                            break;

                        case EQUIPMENT_TYPE.ONE_HAND_SWORD:
                            tYPE = SortBase.TYPE.ONE_HAND_SWORD;
                            break;

                        case EQUIPMENT_TYPE.TWO_HAND_SWORD:
                            tYPE = SortBase.TYPE.TWO_HAND_SWORD;
                            break;

                        case EQUIPMENT_TYPE.SPEAR:
                            tYPE = SortBase.TYPE.SPEAR;
                            break;

                        case EQUIPMENT_TYPE.PAIR_SWORDS:
                            tYPE = SortBase.TYPE.PAIR_SWORDS;
                            break;

                        case EQUIPMENT_TYPE.ARROW:
                            tYPE = SortBase.TYPE.ARROW;
                            break;

                        default:
                            tYPE = SortBase.TYPE.NONE;
                            break;
                        }
                        if ((tYPE & item_type) != 0)
                        {
                            bool flag = true;
                            if (!MonoBehaviourSingleton <InventoryManager> .I.IsHaveingKeyMaterial(createEquipItemTableData.needKeyOrder, createEquipItemTableData.needMaterial))
                            {
                                flag = false;
                            }
                            if ((int)createEquipItemTableData.researchLv > MonoBehaviourSingleton <UserInfoManager> .I.userStatus.researchLv)
                            {
                                flag = false;
                            }
                            if (flag)
                            {
                                list.Add(smithCreateItemInfo);
                                sort_data.Add(new SortData(smithCreateItemInfo, (int)pickup_data.id));
                            }
                        }
                    }
                }
            }
        });
        list.Sort((SmithCreateItemInfo l, SmithCreateItemInfo r) => GetSortIndex(sort_data, l) - GetSortIndex(sort_data, r));
        return(list.ToArray());
    }