public void OnQuery_SELECT_ORDER_FROM_ITEM_DETAIL()
    {
        uint num = (uint)GameSection.GetEventData();

        if (num == 0)
        {
            GameSection.StopEvent();
        }
        else if (!MonoBehaviourSingleton <GameSceneManager> .I.CheckQuestAndOpenUpdateAppDialog(num, true))
        {
            GameSection.StopEvent();
        }
        else
        {
            QuestInfoData questInfoData = MonoBehaviourSingleton <QuestManager> .I.GetQuestInfoData(num);

            if (questInfoData == null)
            {
                GameSection.StopEvent();
            }
            else
            {
                MonoBehaviourSingleton <QuestManager> .I.SetCurrentQuestID(num, true);

                GameSection.SetEventData(questInfoData);
                isScrollViewReady = false;
            }
        }
    }
예제 #2
0
    protected IEnumerator _Initialize()
    {
        questInfo = (GameSection.GetEventData() as QuestInfoData);
        if (questInfo.questData.tableData.questType == QUEST_TYPE.ORDER)
        {
            QuestItemInfo item = MonoBehaviourSingleton <InventoryManager> .I.GetQuestItem(questInfo.questData.tableData.questID);

            if (item != null)
            {
                GameSaveData.instance.RemoveNewIconAndSave(ITEM_ICON_TYPE.QUEST_ITEM, item.uniqueID);
            }
        }
        LoadingQueue load_queue = new LoadingQueue(this);

        if (questInfo != null)
        {
            EnemyTable.EnemyData enemy_data = Singleton <EnemyTable> .I.GetEnemyData((uint)questInfo.questData.tableData.GetMainEnemyID());

            if (enemy_data != null)
            {
                EnemyLoader.CacheUIElementEffect(load_queue, enemy_data.element);
            }
        }
        load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_UI, "ef_ui_questselect_new");
        load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_UI, "ef_ui_questselect_complete");
        if (load_queue.IsLoading())
        {
            yield return((object)load_queue.Wait());
        }
    }
 public override void Initialize()
 {
     object[] array = GameSection.GetEventData() as object[];
     quest   = (array[0] as QuestInfoData);
     haveNum = (int)array[1];
     base.Initialize();
 }
 public void SendGuildRequestStart(QuestInfoData questInfoData, bool isQuestItem, Action <bool> call_back)
 {
     GuildRequestStartModel.RequestSendForm requestSendForm = new GuildRequestStartModel.RequestSendForm();
     requestSendForm.slotNo      = selectedItem.slotNo;
     requestSendForm.questId     = (int)questInfoData.questData.tableData.questID;
     requestSendForm.num         = 1;
     requestSendForm.isQuestItem = (isQuestItem ? 1 : 0);
     Protocol.Send(GuildRequestStartModel.URL, requestSendForm, delegate(GuildRequestStartModel ret)
     {
         bool obj = ErrorCodeChecker.IsSuccess(ret.Error);
         call_back(obj);
     }, string.Empty);
 }
 public void SendGuildRequestExtendAndSortie(QuestInfoData questInfoData, bool isQuestItem, Action <bool> call_back)
 {
     GuildRequestExtendAndStartModel.RequestSendForm requestSendForm = new GuildRequestExtendAndStartModel.RequestSendForm();
     requestSendForm.slotNo      = selectedItem.slotNo;
     requestSendForm.questId     = (int)questInfoData.questData.tableData.questID;
     requestSendForm.num         = 1;
     requestSendForm.isQuestItem = (isQuestItem ? 1 : 0);
     requestSendForm.crystalCL   = MonoBehaviourSingleton <UserInfoManager> .I.userStatus.crystal;
     Protocol.Send(GuildRequestExtendAndStartModel.URL, requestSendForm, delegate(GuildRequestExtendAndStartModel ret)
     {
         bool obj = ErrorCodeChecker.IsSuccess(ret.Error);
         call_back(obj);
     }, string.Empty);
 }
예제 #6
0
    protected virtual void OnQuery_GuildRequestCounterSortieMessage_YES()
    {
        QuestInfoData questInfoData = selectedQuestInfoData;
        bool          flag          = IsFromShadow();

        GameSection.StayEvent();
        MonoBehaviourSingleton <GuildRequestManager> .I.SendGuildRequestStart(questInfoData, !flag, delegate(bool isSuccess)
        {
            GuildRequestCounter guildRequestCounter = this;
            SendGetChallengeInfo(delegate
            {
                guildRequestCounter.UpdateSelectedQuestNum(-1, guildRequestCounter.selectedQuestInfoData.questData.tableData.questID);
                GameSection.ResumeEvent(isSuccess, null);
            }, null);
        });
    }
예제 #7
0
 public override void Initialize()
 {
     //IL_005d: Unknown result type (might be due to invalid IL or missing references)
     selectedQuestInfoData = (GameSection.GetEventData() as QuestInfoData);
     if (selectedQuestInfoData != null)
     {
         if (IsFromShadow())
         {
             selectedQuestNum = MonoBehaviourSingleton <PartyManager> .I.challengeInfo.num;
         }
         else
         {
             selectedQuestNum = selectedQuestInfoData.questData.num;
         }
     }
     this.StartCoroutine(DoInitialize());
 }
예제 #8
0
    public override void SetValue(QuestItem recv_data)
    {
        base.uniqueID = ulong.Parse(recv_data.uniqId);
        base.tableID  = (uint)recv_data.questId;
        QuestTable.QuestTableData questData = Singleton <QuestTable> .I.GetQuestData(base.tableID);

        int[]            mission_clear_status = null;
        ClearStatusQuest clearStatusQuest     = MonoBehaviourSingleton <QuestManager> .I.clearStatusQuest.Find((ClearStatusQuest data) => data.questId == base.tableID);

        if (clearStatusQuest != null)
        {
            mission_clear_status = clearStatusQuest.missionStatus.ToArray();
        }
        infoData    = new QuestInfoData(questData, recv_data.reward, recv_data.num, 0, mission_clear_status);
        sellItems   = recv_data.sellItems;
        remainTimes = recv_data.remainTimes;
    }
    public override void OnQuery_SELECT_ORDER()
    {
        int num = (int)GameSection.GetEventData();

        if (num < 0 || num >= questGridDatas.Length)
        {
            GameSection.StopEvent();
        }
        else if (!MonoBehaviourSingleton <GameSceneManager> .I.CheckQuestAndOpenUpdateAppDialog(questGridDatas[num].questSortData.GetTableID(), true))
        {
            GameSection.StopEvent();
        }
        else
        {
            QuestInfoData infoData = questGridDatas[num].questSortData.itemData.infoData;
            GameSection.SetEventData(infoData);
            isScrollViewReady = false;
        }
    }
예제 #10
0
    private void OnQuery_SORTIE()
    {
        MonoBehaviourSingleton <GuildRequestManager> .I.SetSelectedItem(GameSection.GetEventData() as GuildRequestItem);

        GuildRequestItem selectedItem = MonoBehaviourSingleton <GuildRequestManager> .I.GetSelectedItem();

        QuestInfoData questInfoData = selectedQuestInfoData;
        string        arg           = MonoBehaviourSingleton <GuildRequestManager> .I.GetNeedPoint(questInfoData.questData.tableData.rarity).ToString();

        string needTimeWithFormat = MonoBehaviourSingleton <GuildRequestManager> .I.GetNeedTimeWithFormat(questInfoData.questData.tableData.rarity);

        string   houndRemainTimeWithFormat = selectedItem.GetHoundRemainTimeWithFormat();
        TimeSpan needTime = MonoBehaviourSingleton <GuildRequestManager> .I.GetNeedTime(questInfoData.questData.tableData.rarity);

        TimeSpan houndRemainTime = selectedItem.GetHoundRemainTime();
        string   eventData       = (!(0.0 < houndRemainTime.TotalSeconds) || !(houndRemainTime < needTime)) ? string.Format(StringTable.Get(STRING_CATEGORY.GUILD_REQUEST, 0u), arg, needTimeWithFormat) : string.Format(StringTable.Get(STRING_CATEGORY.GUILD_REQUEST, 5u), arg, needTimeWithFormat, houndRemainTimeWithFormat);

        GameSection.SetEventData(eventData);
    }
    public virtual void OnQuery_SELECT_ORDER()
    {
        int num = (int)GameSection.GetEventData();

        if (num < 0 || num >= challengeData.Length)
        {
            GameSection.StopEvent();
        }
        else if (!MonoBehaviourSingleton <GameSceneManager> .I.CheckQuestAndOpenUpdateAppDialog((uint)challengeData[num].questId, true))
        {
            GameSection.StopEvent();
        }
        else
        {
            MonoBehaviourSingleton <QuestManager> .I.SetCurrentQuestID((uint)challengeData[num].questId, true);

            QuestInfoData questChallengeInfoData = MonoBehaviourSingleton <QuestManager> .I.GetQuestChallengeInfoData((uint)challengeData[num].questId);

            GameSection.SetEventData(questChallengeInfoData);
            isScrollViewReady = false;
        }
    }
    private bool IsNewItemQuestEnemySpecies(QuestItemInfo questItem)
    {
        bool result = true;

        if (questItem == null)
        {
            return(result);
        }
        QuestInfoData infoData = questItem.infoData;

        if (infoData == null)
        {
            return(result);
        }
        QuestInfoData.Quest questData = infoData.questData;
        if (questData == null)
        {
            return(result);
        }
        QuestTable.QuestTableData tableData = questData.tableData;
        if (tableData == null)
        {
            return(result);
        }
        ClearStatusQuestEnemySpecies clearStatusQuestEnemySpecies = MonoBehaviourSingleton <QuestManager> .I.GetClearStatusQuestEnemySpecies(tableData.questID);

        if (clearStatusQuestEnemySpecies == null)
        {
            return(result);
        }
        if (clearStatusQuestEnemySpecies.questStatus != 1)
        {
            result = false;
        }
        return(result);
    }
예제 #13
0
    public override void UpdateUI()
    {
        UI[] array = new UI[3]
        {
            UI.OBJ_MISSION_INFO_1,
            UI.OBJ_MISSION_INFO_2,
            UI.OBJ_MISSION_INFO_3
        };
        UI[] array2 = new UI[3]
        {
            UI.OBJ_TOP_CROWN_1,
            UI.OBJ_TOP_CROWN_2,
            UI.OBJ_TOP_CROWN_3
        };
        UI[] array3 = new UI[3]
        {
            UI.LBL_MISSION_INFO_1,
            UI.LBL_MISSION_INFO_2,
            UI.LBL_MISSION_INFO_3
        };
        UI[] array4 = new UI[3]
        {
            UI.SPR_MISSION_INFO_CROWN_1,
            UI.SPR_MISSION_INFO_CROWN_2,
            UI.SPR_MISSION_INFO_CROWN_3
        };
        UI[] array5 = new UI[3]
        {
            UI.SPR_CROWN_1,
            UI.SPR_CROWN_2,
            UI.SPR_CROWN_3
        };
        QuestInfoData info      = questInfo;
        QUEST_TYPE    questType = info.questData.tableData.questType;
        int           num       = 0;

        SetFontStyle((Enum)UI.STR_MISSION, 2);
        SetFontStyle((Enum)UI.STR_TREASURE, 2);
        SetFontStyle((Enum)UI.STR_SELL, 2);
        string text = null;

        switch (questType)
        {
        default:
            text = "STR_QUEST_TYPE_NORMAL";
            break;

        case QUEST_TYPE.ORDER:
            text = "STR_QUEST_TYPE_ORDER";
            break;

        case QUEST_TYPE.EVENT:
            text = "STR_QUEST_TYPE_EVENT";
            break;

        case QUEST_TYPE.STORY:
            text = "STR_QUEST_TYPE_STORY";
            break;
        }
        SetText((Enum)UI.LBL_QUEST_TYPE, text);
        SetLabelText((Enum)UI.LBL_QUEST_NUM, string.Format(base.sectionData.GetText("QUEST_NUMBER"), info.questData.tableData.locationNumber, info.questData.tableData.questNumber));
        SetLabelText((Enum)UI.LBL_QUEST_NAME, info.questData.tableData.questText);
        int num2 = (int)info.questData.tableData.limitTime;

        SetLabelText((Enum)UI.LBL_LIMIT_TIME, $"{num2 / 60:D2}:{num2 % 60:D2}");
        SetActive((Enum)UI.LBL_GUILD_REQUEST_NEED_POINT, false);
        SetActive((Enum)UI.STR_MISSION_EMPTY, false);
        if (!info.isExistMission)
        {
            SetActive((Enum)UI.OBJ_MISSION_INFO_ROOT, false);
        }
        else
        {
            SetActive((Enum)UI.OBJ_MISSION_INFO_ROOT, true);
            int i = 0;
            for (int num3 = info.missionData.Length; i < num3; i++)
            {
                SetActive((Enum)array[i], info.missionData[i] != null);
                SetActive((Enum)array2[i], info.missionData[i] != null);
                if (info.missionData[i] != null)
                {
                    SetActive((Enum)array4[i], info.missionData[i].state >= CLEAR_STATUS.CLEAR);
                    SetActive((Enum)array5[i], info.missionData[i].state >= CLEAR_STATUS.CLEAR);
                    SetLabelText((Enum)array3[i], info.missionData[i].tableData.missionText);
                }
            }
        }
        if (questType == QUEST_TYPE.ORDER)
        {
            SetActive((Enum)UI.OBJ_SELL_ITEM, true);
            QuestItemInfo quest_item = MonoBehaviourSingleton <InventoryManager> .I.GetQuestItem(info.questData.tableData.questID);

            if (quest_item != null && quest_item.sellItems != null && quest_item.sellItems.Count > 0)
            {
                SetGrid(UI.GRD_REWARD_SELL, string.Empty, quest_item.sellItems.Count, false, delegate(int i_2, Transform t_2, bool is_recycle_2)
                {
                    QuestItem.SellItem sellItem = quest_item.sellItems[i_2];
                    REWARD_TYPE type2           = (REWARD_TYPE)sellItem.type;
                    uint itemId = (uint)sellItem.itemId;
                    if (sellItem.num <= 0)
                    {
                        Log.Error(LOG.OUTGAME, "QuestItem sold get item num is zero. type={0},itemId={1}", type2, itemId);
                    }
                    else
                    {
                        int num4           = -1;
                        ItemIcon itemIcon4 = ItemIcon.CreateRewardItemIcon(type2, itemId, t_2, num4, null, 0, false, -1, false, null, false, false, ItemIcon.QUEST_ICON_SIZE_TYPE.DEFAULT);
                        SetMaterialInfo(itemIcon4.transform, type2, itemId, null);
                    }
                });
            }
            SetActive((Enum)UI.OBJ_TOP_CROWN_ROOT, false);
        }
        SetActive((Enum)UI.OBJ_TREASURE, true);
        SetGrid(UI.GRD_REWARD_QUEST, string.Empty, 5, false, delegate(int i_2, Transform t_2, bool is_recycle_2)
        {
            if (info.questData.reward != null && info.questData.reward.Length > i_2)
            {
                REWARD_TYPE type   = (REWARD_TYPE)info.questData.reward[i_2].type;
                uint id            = (uint)info.questData.reward[i_2].id;
                ItemIcon itemIcon3 = ItemIcon.CreateRewardItemIcon(type, id, t_2, -1, null, 0, false, -1, false, null, false, false, ItemIcon.QUEST_ICON_SIZE_TYPE.DEFAULT);
                SetMaterialInfo(itemIcon3.transform, type, id, null);
            }
        });
        EnemyTable.EnemyData enemyData = Singleton <EnemyTable> .I.GetEnemyData((uint)info.questData.tableData.GetMainEnemyID());

        if (enemyData != null)
        {
            int         iconId   = enemyData.iconId;
            RARITY_TYPE?rarity   = (info.questData.tableData.questType != QUEST_TYPE.ORDER) ? null : new RARITY_TYPE?(info.questData.tableData.rarity);
            ItemIcon    itemIcon = ItemIcon.Create(ITEM_ICON_TYPE.QUEST_ITEM, iconId, rarity, GetCtrl(UI.OBJ_ENEMY), enemyData.element, null, -1, null, 0, false, -1, false, null, false, 0, 0, false, GET_TYPE.PAY);
            itemIcon.SetEnableCollider(false);
            ItemIcon itemIcon2 = ItemIcon.Create(ITEM_ICON_TYPE.QUEST_ITEM, iconId, rarity, GetCtrl(UI.OBJ_ENEMY), enemyData.element, null, -1, null, 0, false, -1, false, null, false, 0, 0, false, GET_TYPE.PAY);
            itemIcon2.SetEnableCollider(false);
        }
        SetActive((Enum)UI.SPR_ELEMENT_ROOT, false);
        if (enemyData != null)
        {
            SetActive((Enum)UI.SPR_ELEMENT_ROOT_2, true);
            SetElementSprite((Enum)UI.SPR_ELEMENT_2, (int)enemyData.element);
            SetActive((Enum)UI.STR_NON_ELEMENT_2, enemyData.element == ELEMENT_TYPE.MAX);
            SetElementSprite((Enum)UI.SPR_WEAK_ELEMENT_2, (int)enemyData.weakElement);
            SetActive((Enum)UI.STR_NON_WEAK_ELEMENT_2, enemyData.weakElement == ELEMENT_TYPE.MAX);
        }
        else
        {
            SetActive((Enum)UI.SPR_ELEMENT_ROOT_2, false);
            SetActive((Enum)UI.STR_NON_WEAK_ELEMENT_2, false);
        }
        ShowInfo(questType, isShowDropInfo);
        SetActive((Enum)UI.TWN_DIFFICULT_STAR, false);
        num = (MonoBehaviourSingleton <QuestManager> .I.GetClearStatusQuestEnemySpecies(info.questData.tableData.questID)?.questStatus ?? 1);
        SetClearStatus((CLEAR_STATUS)num);
        if (!MonoBehaviourSingleton <UserInfoManager> .I.isGuildRequestOpen)
        {
            SetActive((Enum)UI.BTN_GUILD_REQUEST, false);
        }
    }
예제 #14
0
        public QuestDataSet(QuestData questData, QuestTable.QuestTableData tableData)
        {
            questInfoData = MonoBehaviourSingleton <QuestManager> .I.CreateQuestChallengeInfoData(questData, tableData);

            this.tableData = tableData;
        }
예제 #15
0
    public void Initialize()
    {
        //IL_01f3: Unknown result type (might be due to invalid IL or missing references)
        QuestTable.QuestTableData questData = Singleton <QuestTable> .I.GetQuestData(MonoBehaviourSingleton <QuestManager> .I.currentQuestID);

        if (MonoBehaviourSingleton <QuestManager> .I.IsExplore())
        {
            partyMenuUI.SetActive(true);
            normalMenuUI.SetActive(false);
            happenMenuUI.SetActive(false);
            retryableMenuUI.SetActive(false);
            string text = MonoBehaviourSingleton <PartyManager> .I.GetPartyNumber();

            if (string.IsNullOrEmpty(text))
            {
                partyNumber.text = "-";
            }
            else
            {
                partyNumber.text = text;
            }
        }
        else if (questData != null && questData.questType == QUEST_TYPE.HAPPEN)
        {
            partyMenuUI.SetActive(false);
            normalMenuUI.SetActive(false);
            happenMenuUI.SetActive(true);
            retryableMenuUI.SetActive(false);
            QuestInfoData.Mission[] array = null;
            array = QuestInfoData.CreateMissionData(questData);
            if (array != null)
            {
                int i = 0;
                for (int num = array.Length; i < num; i++)
                {
                    QuestInfoData.Mission mission = array[i];
                    m_missionCrownOn[i].SetActive(CLEAR_STATUS.CLEAR == mission.state);
                    m_missionCrownOff[i].SetActive(CLEAR_STATUS.CLEAR != mission.state);
                    m_missionTexts[i].text = mission.tableData.missionText;
                }
            }
        }
        else if (questData != null && questData.questType == QUEST_TYPE.ARENA)
        {
            partyMenuUI.SetActive(false);
            normalMenuUI.SetActive(false);
            happenMenuUI.SetActive(false);
            retryableMenuUI.SetActive(true);
        }
        else
        {
            partyMenuUI.SetActive(false);
            normalMenuUI.SetActive(true);
            happenMenuUI.SetActive(false);
            retryableMenuUI.SetActive(false);
        }
        if (MonoBehaviourSingleton <UIManager> .IsValid() && MonoBehaviourSingleton <UIManager> .I.mainChat != null)
        {
            MonoBehaviourSingleton <UIManager> .I.mainChat.HideAll();
        }
        this.get_gameObject().SetActive(true);
    }
    private void UpdateGirdListItemQuest(int i, Transform t, bool is_recycle)
    {
        //IL_0427: Unknown result type (might be due to invalid IL or missing references)
        //IL_044c: Unknown result type (might be due to invalid IL or missing references)
        List <GameSectionHistory.HistoryData> historyList = MonoBehaviourSingleton <GameSceneManager> .I.GetHistoryList();

        bool flag = historyList.Any((GameSectionHistory.HistoryData h) => h.sectionName.StartsWith("GuildRequest"));

        SetActive(t, true);
        SetEvent(t, "SELECT_ORDER", i);
        QuestSortData questSortData = questGridDatas[i].questSortData;
        UIScrollView  component     = GetCtrl(UI.SCR_ORDER_QUEST).GetComponent <UIScrollView>();
        QuestInfoData info          = questSortData.itemData.infoData;

        if (flag)
        {
            SetActive(t, UI.TWN_DIFFICULT_STAR, false);
            SetActive(t, UI.TXT_NEED_POINT, true);
            string text = string.Format(StringTable.Get(STRING_CATEGORY.GUILD_REQUEST, 6u), MonoBehaviourSingleton <GuildRequestManager> .I.GetNeedPoint(info.questData.tableData.rarity), MonoBehaviourSingleton <GuildRequestManager> .I.GetNeedTimeWithFormat(info.questData.tableData.rarity));
            SetLabelText(t, UI.TXT_NEED_POINT, text);
        }
        else
        {
            SetActive(t, UI.TWN_DIFFICULT_STAR, false);
            SetActive(t, UI.TXT_NEED_POINT, false);
        }
        EnemyTable.EnemyData enemyData = Singleton <EnemyTable> .I.GetEnemyData((uint)info.questData.tableData.GetMainEnemyID());

        QuestSortData questSortData2 = questSortData;
        ItemIcon      icon           = ItemIcon.Create(questSortData2.GetIconType(), questSortData2.GetIconID(), questSortData2.GetRarity(), FindCtrl(t, UI.OBJ_ENEMY), questSortData2.GetIconElement(), null, -1, null, 0, false, -1, false, null, false, 0, 0, false, GET_TYPE.PAY);

        icon.SetEnableCollider(false);
        SetActive(t, UI.SPR_ELEMENT_ROOT, enemyData.element != ELEMENT_TYPE.MAX);
        SetElementSprite(t, UI.SPR_ELEMENT, (int)enemyData.element);
        SetElementSprite(t, UI.SPR_WEAK_ELEMENT, (int)enemyData.weakElement);
        SetActive(t, UI.STR_NON_WEAK_ELEMENT, enemyData.weakElement == ELEMENT_TYPE.MAX);
        SetLabelText(t, UI.LBL_QUEST_NAME, info.questData.tableData.questText);
        int num = 1;
        ClearStatusQuestEnemySpecies clearStatusQuestEnemySpecies = MonoBehaviourSingleton <QuestManager> .I.GetClearStatusQuestEnemySpecies(info.questData.tableData.questID);

        if (clearStatusQuestEnemySpecies != null)
        {
            num = clearStatusQuestEnemySpecies.questStatus;
        }
        int value = i + 100;

        SetToggleGroup(t, UI.OBJ_ICON_NEW, value);
        SetToggleGroup(t, UI.OBJ_ICON_CLEARED, value);
        SetToggleGroup(t, UI.OBJ_ICON_COMPLETE, value);
        CLEAR_STATUS cLEAR_STATUS = (CLEAR_STATUS)num;

        if (cLEAR_STATUS != CLEAR_STATUS.NEW)
        {
            SetToggle(t, UI.OBJ_ICON_NEW, false);
            SetToggle(t, UI.OBJ_ICON_CLEARED, false);
            SetToggle(t, UI.OBJ_ICON_COMPLETE, false);
            SetActive(t, UI.OBJ_ICON_ROOT, false);
            SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_NEW, null);
            SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_COMPLETE, null);
        }
        else
        {
            SetActive(t, UI.OBJ_ICON_ROOT, true);
            SetToggle(t, UI.OBJ_ICON_NEW, true);
            SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_COMPLETE, null);
            SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_NEW, "ef_ui_questselect_new");
        }
        int num2 = info.questData.num;
        int num3 = 0;

        if (MonoBehaviourSingleton <UserInfoManager> .I.isGuildRequestOpen)
        {
            num3 = (from g in MonoBehaviourSingleton <GuildRequestManager> .I.guildRequestData.guildRequestItemList
                    where g.questId == (int)info.questData.tableData.questID
                    select g).Count();
        }
        int num4 = num2 - num3;

        SetLabelText(t, UI.LBL_ORDER_NUM, num4.ToString());
        if (num4 <= 0)
        {
            t.GetComponent <UIButton>().isEnabled = false;
        }
        Transform val = FindCtrl(t, UI.OBJ_FRAME);

        if (val != null)
        {
            UIPanel uiPanel = val.get_gameObject().GetComponent <UIPanel>();
            if (uiPanel == null)
            {
                uiPanel       = val.get_gameObject().AddComponent <UIPanel>();
                uiPanel.depth = component.panel.depth + 1;
            }
            uiPanel.widgetsAreStatic = false;
            if (isScrollViewReady)
            {
                PanelToStatic(icon, uiPanel);
            }
            else
            {
                onScrollViewReady = (Action)Delegate.Combine(onScrollViewReady, (Action) delegate
                {
                    PanelToStatic(icon, uiPanel);
                });
            }
        }
        QuestItemInfo itemData   = questSortData.itemData;
        bool          is_visible = false;

        foreach (float remainTime in itemData.remainTimes)
        {
            float num5 = remainTime;
            if (num5 < SHOW_QUEST_REMAIN_LIMIT_SECOND)
            {
                is_visible = true;
                break;
            }
        }
        SetLabelText(t, UI.LBL_REMAIN, StringTable.Get(STRING_CATEGORY.GATE_QUEST_NAME, 1u));
        SetActive(t, UI.LBL_REMAIN, is_visible);
    }
    protected void ShowOrder()
    {
        if (MonoBehaviourSingleton <InventoryManager> .I.questItemInventory.GetCount() > 0)
        {
            List <QuestItemInfo> list = new List <QuestItemInfo>();
            MonoBehaviourSingleton <InventoryManager> .I.ForAllQuestInvetory(delegate(QuestItemInfo item)
            {
                if (IsSetQuestItemInfoByOrderQuest(item))
                {
                    if (isQuestItemDirty)
                    {
                        GetRemainingTimeAndExpiredNum(item, out float remainTime, out int expiredNum);
                        if (remainTime > 0f)
                        {
                            item.infoData.questData.num -= expiredNum;
                            if (item.infoData.questData.num > 0)
                            {
                                list.Add(item);
                            }
                        }
                    }
                    else if (item.infoData.questData.num > 0)
                    {
                        list.Add(item);
                    }
                }
            });

            Search(ref list);
            questItemAry = list.ToArray();
        }
        List <QuestGridData> list2 = new List <QuestGridData>();

        if (MonoBehaviourSingleton <PartyManager> .IsValid() && MonoBehaviourSingleton <PartyManager> .I.challengeInfo.IsEnable())
        {
            list2.Add(new QuestGridData(QuestGridData.ORDER_QUEST_TYPE.Challenge, null));
        }
        if (questItemAry != null && questItemAry.Length != 0)
        {
            QuestSortData[] array = sortSettings.CreateSortAry <QuestItemInfo, QuestSortData>(questItemAry);
            if (array != null)
            {
                int i = 0;
                for (int num = array.Length; i < num; i++)
                {
                    QuestSortData questSortData = array[i];
                    QuestInfoData info          = questSortData.itemData.infoData;
                    int           num2          = info.questData.num;
                    int           num3          = 0;
                    if (MonoBehaviourSingleton <UserInfoManager> .I.isGuildRequestOpen)
                    {
                        num3 = (from g in MonoBehaviourSingleton <GuildRequestManager> .I.guildRequestData.guildRequestItemList
                                where g.questId == (int)info.questData.tableData.questID
                                select g).Count();
                    }
                    int num4 = num2 - num3;
                    if (num4 > 0)
                    {
                        list2.Add(new QuestGridData(QuestGridData.ORDER_QUEST_TYPE.Quest, array[i]));
                    }
                }
            }
        }
        questGridDatas = list2.ToArray();
        if (questGridDatas == null || questGridDatas.Length == 0)
        {
            SetActive((Enum)UI.GRD_ORDER_QUEST, false);
            SetActive((Enum)UI.STR_ORDER_NON_LIST, true);
            SetActive((Enum)UI.OBJ_ACTIVE_ROOT, false);
            SetActive((Enum)UI.OBJ_INACTIVE_ROOT, true);
            SetLabelText((Enum)UI.LBL_MAX, "0");
            SetLabelText((Enum)UI.LBL_NOW, "0");
            UIScrollView component = GetCtrl(UI.SCR_ORDER_QUEST).GetComponent <UIScrollView>();
            if (component != null)
            {
                component.set_enabled(false);
                component.verticalScrollBar.alpha = 0f;
            }
        }
        else
        {
            if (questGridDatas.Length == 1 && questGridDatas[0].orderQuestType == QuestGridData.ORDER_QUEST_TYPE.Challenge)
            {
                SetActive((Enum)UI.STR_ORDER_NON_LIST, true);
            }
            else
            {
                SetActive((Enum)UI.STR_ORDER_NON_LIST, false);
            }
            SetActive((Enum)UI.GRD_ORDER_QUEST, true);
            SetLabelText((Enum)UI.LBL_SORT, sortSettings.GetSortLabel());
            SetToggle((Enum)UI.TGL_ICON_ASC, sortSettings.orderTypeAsc);
            pageMax = 1 + (questGridDatas.Length - 1) / 10;
            bool flag = pageMax > 1;
            SetActive((Enum)UI.OBJ_ACTIVE_ROOT, flag);
            SetActive((Enum)UI.OBJ_INACTIVE_ROOT, !flag);
            SetLabelText((Enum)UI.LBL_MAX, pageMax.ToString());
            SetLabelText((Enum)UI.LBL_NOW, nowPage.ToString());
            UITweener[] transitions = GetCtrl(UI.OBJ_FRAME).GetComponents <UITweener>();
            int         finishCount = 0;
            UITweener[] array2      = transitions;
            foreach (UITweener uITweener in array2)
            {
                uITweener.AddOnFinished(delegate
                {
                    finishCount++;
                    if (finishCount >= transitions.Length)
                    {
                        isTransitionFinished = true;
                    }
                });
            }
            int             num5             = 10 * (nowPage - 1);
            int             num6             = (nowPage != pageMax) ? 10 : (questGridDatas.Length - num5);
            QuestGridData[] destinationArray = new QuestGridData[num6];
            Array.Copy(questGridDatas, num5, destinationArray, 0, num6);
            questGridDatas = destinationArray;
            SetGrid(UI.GRD_ORDER_QUEST, string.Empty, 0, true, null, null);
            SetGrid(UI.GRD_ORDER_QUEST, "QuestListOrderItem", questGridDatas.Length, true, CreateGridListItem, UpdateGridListItem);
        }
    }
    public override void UpdateUI()
    {
        //IL_017c: Unknown result type (might be due to invalid IL or missing references)
        Desc desc = GameSection.GetEventData() as Desc;

        if (desc != null)
        {
            QuestTable.QuestTableData questData = desc.questData;
            if (questData != null)
            {
                EnemyTable.EnemyData enemyData = Singleton <EnemyTable> .I.GetEnemyData((uint)questData.GetMainEnemyID());

                if (enemyData != null)
                {
                    int mainEnemyLv = questData.GetMainEnemyLv();
                    SetLabelText((Enum)UI.LBL_NAME, enemyData.name);
                    SetLabelText((Enum)UI.NUM_LV, mainEnemyLv.ToString());
                    SetElementSprite((Enum)UI.STR_ELEM, (int)enemyData.weakElement);
                    if (enemyData.weakElement != ELEMENT_TYPE.MAX)
                    {
                        SetActive((Enum)UI.STR_WEAK_NONE, false);
                    }
                    int num  = (int)(questData.limitTime / 60f);
                    int num2 = (int)(questData.limitTime % 60f);
                    SetLabelText((Enum)UI.NUM_TIMER, $"{num:D2}:{num2:D2}");
                    UI[] array = new UI[10]
                    {
                        UI.OBJ_DIFFICULT_STAR_1,
                        UI.OBJ_DIFFICULT_STAR_2,
                        UI.OBJ_DIFFICULT_STAR_3,
                        UI.OBJ_DIFFICULT_STAR_4,
                        UI.OBJ_DIFFICULT_STAR_5,
                        UI.OBJ_DIFFICULT_STAR_6,
                        UI.OBJ_DIFFICULT_STAR_7,
                        UI.OBJ_DIFFICULT_STAR_8,
                        UI.OBJ_DIFFICULT_STAR_9,
                        UI.OBJ_DIFFICULT_STAR_10
                    };
                    int num3 = (int)(questData.difficulty + 1);
                    int i    = 0;
                    for (int num4 = array.Length; i < num4; i++)
                    {
                        SetActive((Enum)array[i], i < num3);
                    }
                    PlayTween((Enum)UI.TWN_DIFFICULT_STAR, true, (EventDelegate.Callback)null, false, 0);
                    QuestInfoData.Mission[] array2 = QuestInfoData.CreateMissionData(questData);
                    if (array2 != null)
                    {
                        GetCtrl(UI.MISSION).get_gameObject().SetActive(true);
                        UI[] array3 = new UI[3]
                        {
                            UI.MISSION_LABEL_01,
                            UI.MISSION_LABEL_02,
                            UI.MISSION_LABEL_03
                        };
                        UI[] array4 = new UI[3]
                        {
                            UI.MISSION_CROWN_ON_01,
                            UI.MISSION_CROWN_ON_02,
                            UI.MISSION_CROWN_ON_03
                        };
                        UI[] array5 = new UI[3]
                        {
                            UI.MISSION_CROWN_OFF_01,
                            UI.MISSION_CROWN_OFF_02,
                            UI.MISSION_CROWN_OFF_03
                        };
                        int num5 = Mathf.Min(array2.Length, 3);
                        for (int j = 0; j < num5; j++)
                        {
                            QuestInfoData.Mission mission = array2[j];
                            SetActive((Enum)array4[j], CLEAR_STATUS.CLEAR == mission.state);
                            SetActive((Enum)array5[j], CLEAR_STATUS.CLEAR != mission.state);
                            SetLabelText((Enum)array3[j], mission.tableData.missionText);
                        }
                    }
                    if (desc.reward != null)
                    {
                        Array.Sort(desc.reward, (QuestInfoData.Quest.Reward l, QuestInfoData.Quest.Reward r) => l.priority - r.priority);
                    }
                    SetFontStyle((Enum)UI.LBL_NAME, 2);
                    SetFontStyle((Enum)UI.NUM_LV, 2);
                    SetFontStyle((Enum)UI.LBL_LV, 2);
                    countAnimStep = 0;
                    timeLimit     = MonoBehaviourSingleton <InGameSettingsManager> .I.happenQuestDirection.confirmUITime;
                    prevTime      = -1;
                    isAnswer      = false;
                    Update();
                    UpdateAnchors();
                    PlayTween((Enum)UI.OBJ_FRAME, true, (EventDelegate.Callback)null, true, 0);
                    PlayTween((Enum)UI.COUNT_ANIM_0, true, (EventDelegate.Callback)null, false, 0);
                }
            }
        }
    }
    protected virtual void ShowSelectUI()
    {
        //IL_0240: Unknown result type (might be due to invalid IL or missing references)
        //IL_024f: Unknown result type (might be due to invalid IL or missing references)
        int num  = (!isInGameScene && TutorialStep.HasQuestSpecialUnlocked()) ? 1 : 2;
        int num2 = (showMode != 0) ? num : 0;
        int num3 = (showMode != SHOW_MODE.QUEST) ? num : 0;
        int num4 = (showMode != SHOW_MODE.ORDER) ? num : 0;

        SetActive((Enum)UI.OBJ_DELIVERY_ROOT, showMode == SHOW_MODE.DELIVERY);
        SetActive((Enum)UI.OBJ_QUEST_ROOT, showMode == SHOW_MODE.QUEST);
        SetActive((Enum)UI.OBJ_ORDER_ROOT, showMode == SHOW_MODE.ORDER);
        SetButtonSprite((Enum)UI.BTN_DELIVERY, "QuestTabBtnBase" + SPR_ON_OFF[num2], true);
        SetSprite((Enum)UI.SPR_DELIVERY_TEXT, "QuestTabBtnText" + SPR_INDEX[0] + SPR_ON_OFF[num2]);
        SetSprite((Enum)UI.SPR_DELIVERY_ICON, "QuestTabBtnIcon" + SPR_INDEX[0] + SPR_ON_OFF[num2]);
        SetButtonSprite((Enum)UI.BTN_QUEST, "QuestTabBtnBase" + SPR_ON_OFF[num3], true);
        SetSprite((Enum)UI.SPR_QUEST_TEXT, "QuestTabBtnText" + SPR_INDEX[1] + SPR_ON_OFF[num3]);
        SetSprite((Enum)UI.SPR_QUEST_ICON, "QuestTabBtnIcon" + SPR_INDEX[1] + SPR_ON_OFF[num3]);
        SetButtonSprite((Enum)UI.BTN_ORDER, "QuestTabBtnBase" + SPR_ON_OFF[num4], true);
        SetSprite((Enum)UI.SPR_ORDER_TEXT, "QuestTabBtnText" + SPR_INDEX[2] + SPR_ON_OFF[num4]);
        SetSprite((Enum)UI.SPR_ORDER_ICON, "QuestTabBtnIcon" + SPR_INDEX[2] + SPR_ON_OFF[num4]);
        if (!TutorialStep.HasQuestSpecialUnlocked())
        {
            SetButtonEnabled((Enum)UI.BTN_QUEST, false);
            SetButtonEnabled((Enum)UI.BTN_ORDER, false);
            SetActive((Enum)UI.BTN_EVENT, false);
        }
        if (!isInGameScene)
        {
            SetRenderNPCModel((Enum)UI.TEX_NPCMODEL, 0, MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.questCenterNPCPos, MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.questCenterNPCRot, MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.questCenterNPCFOV, (Action <NPCLoader>)null);
            SetLabelText((Enum)UI.LBL_NPC_MESSAGE, npcText);
        }
        SetActive((Enum)UI.OBJ_NPC_MESSAGE, !isInGameScene);
        if (showMode == SHOW_MODE.DELIVERY)
        {
            SetActive((Enum)UI.SPR_TAB_NORMAL, UI.BTN_TAB_NORMAL == selectedTab);
            SetActive((Enum)UI.SPR_TAB_DAILY, UI.BTN_TAB_DAILY == selectedTab);
            SetActive((Enum)UI.SPR_TAB_WEEKLY, UI.BTN_TAB_WEEKLY == selectedTab);
            SetButtonSprite((Enum)UI.BTN_TAB_NORMAL, (selectedTab != UI.BTN_TAB_NORMAL) ? "PickeShopBtn_Normal_off" : "PickeShopBtn_Green_on", false);
            SetButtonSprite((Enum)UI.BTN_TAB_DAILY, (selectedTab != UI.BTN_TAB_DAILY) ? "PickeShopBtn_Normal_off" : "PickeShopBtn_Green_on", false);
            SetButtonSprite((Enum)UI.BTN_TAB_WEEKLY, (selectedTab != UI.BTN_TAB_WEEKLY) ? "PickeShopBtn_Normal_off" : "PickeShopBtn_Green_on", false);
            SetNPCMessage(selectedTab);
            switch (selectedTab)
            {
            case UI.BTN_TAB_NORMAL:
                SetDeliveryList(normalDeliveryInfo);
                break;

            case UI.BTN_TAB_DAILY:
                SetDeliveryList(dailyDeliveryInfo);
                break;

            case UI.BTN_TAB_WEEKLY:
                SetDeliveryList(weeklyDeliveryInfo);
                break;
            }
        }
        else if (showMode == SHOW_MODE.ORDER)
        {
            if (questItemAry == null && MonoBehaviourSingleton <InventoryManager> .I.questItemInventory.GetCount() > 0)
            {
                List <QuestItemInfo> list = new List <QuestItemInfo>();
                MonoBehaviourSingleton <InventoryManager> .I.ForAllQuestInvetory(delegate(QuestItemInfo item)
                {
                    if (item.infoData.questData.num > 0)
                    {
                        list.Add(item);
                    }
                });

                questItemAry = list.ToArray();
                GetCtrl(UI.GRD_ORDER_QUEST).DestroyChildren();
            }
            if (questItemAry == null || questItemAry.Length == 0)
            {
                SetActive((Enum)UI.BTN_SORT, false);
                SetActive((Enum)UI.GRD_ORDER_QUEST, false);
                SetActive((Enum)UI.STR_ORDER_NON_LIST, true);
            }
            else
            {
                questSortData = sortSettings.CreateSortAry <QuestItemInfo, QuestSortData>(questItemAry);
                SetActive((Enum)UI.GRD_ORDER_QUEST, true);
                SetActive((Enum)UI.STR_ORDER_NON_LIST, false);
                SetActive((Enum)UI.BTN_SORT, true);
                SetLabelText((Enum)UI.LBL_SORT, sortSettings.GetSortLabel());
                SetToggle((Enum)UI.TGL_ICON_ASC, sortSettings.orderTypeAsc);
                SetDynamicList((Enum)UI.GRD_ORDER_QUEST, "QuestListOrderItem", questSortData.Length, false, (Func <int, bool>) null, (Func <int, Transform, Transform>) null, (Action <int, Transform, bool>) delegate(int i, Transform t, bool is_recycle)
                {
                    QuestSpecialSelect questSpecialSelect2 = this;
                    SetActive(t, true);
                    SetEvent(t, "SELECT_ORDER", i);
                    QuestInfoData info2 = this.questSortData[i].itemData.infoData;
                    int num9            = (int)(info2.questData.tableData.difficulty + 1);
                    int l = 0;
                    for (int num10 = difficult.Length; l < num10; l++)
                    {
                        SetActive(t, difficult[l], l < num9);
                    }
                    if (!is_recycle)
                    {
                        ResetTween(t, UI.TWN_DIFFICULT_STAR, 0);
                        PlayTween(t, UI.TWN_DIFFICULT_STAR, true, null, false, 0);
                    }
                    EnemyTable.EnemyData enemyData2 = Singleton <EnemyTable> .I.GetEnemyData((uint)info2.questData.tableData.GetMainEnemyID());
                    QuestSortData questSortData     = this.questSortData[i];
                    ItemIcon itemIcon2 = ItemIcon.Create(questSortData.GetIconType(), questSortData.GetIconID(), questSortData.GetRarity(), FindCtrl(t, UI.OBJ_ENEMY), questSortData.GetIconElement(), null, -1, null, 0, false, -1, false, null, false, 0, 0, false, GET_TYPE.PAY);
                    itemIcon2.SetEnableCollider(false);
                    SetActive(t, UI.SPR_ELEMENT_ROOT, enemyData2.element != ELEMENT_TYPE.MAX);
                    SetElementSprite(t, UI.SPR_ELEMENT, (int)enemyData2.element);
                    SetElementSprite(t, UI.SPR_WEAK_ELEMENT, (int)enemyData2.weakElement);
                    SetActive(t, UI.STR_NON_WEAK_ELEMENT, enemyData2.weakElement == ELEMENT_TYPE.MAX);
                    SetLabelText(t, UI.LBL_QUEST_NAME, info2.questData.tableData.questText);
                    int num11 = 1;
                    ClearStatusQuest clearStatusQuest2 = MonoBehaviourSingleton <QuestManager> .I.clearStatusQuest.Find((ClearStatusQuest data) => info2.questData.tableData.questID == data.questId);
                    if (clearStatusQuest2 != null)
                    {
                        num11 = clearStatusQuest2.questStatus;
                    }
                    int value2 = i + 100;
                    SetToggleGroup(t, UI.OBJ_ICON_NEW, value2);
                    SetToggleGroup(t, UI.OBJ_ICON_CLEARED, value2);
                    SetToggleGroup(t, UI.OBJ_ICON_COMPLETE, value2);
                    switch (num11)
                    {
                    default:
                        SetToggle(t, UI.OBJ_ICON_NEW, false);
                        SetToggle(t, UI.OBJ_ICON_CLEARED, false);
                        SetToggle(t, UI.OBJ_ICON_COMPLETE, false);
                        break;

                    case 1:
                        SetToggle(t, UI.OBJ_ICON_NEW, true);
                        SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_NEW, "ef_ui_questselect_new");
                        break;

                    case 3:
                        SetToggle(t, UI.OBJ_ICON_CLEARED, true);
                        break;

                    case 4:
                        SetToggle(t, UI.OBJ_ICON_COMPLETE, true);
                        SetVisibleWidgetEffect(UI.SCR_ORDER_QUEST, t, UI.SPR_ICON_COMPLETE, "ef_ui_questselect_complete");
                        break;
                    }
                    SetLabelText(t, UI.LBL_ORDER_NUM, info2.questData.num.ToString());
                    SetActive(t, UI.LBL_REMAIN, false);
                });
            }
        }
        else if (showMode == SHOW_MODE.QUEST)
        {
            if (questInfo == null || questInfo.Length == 0)
            {
                SetActive((Enum)UI.GRD_QUEST, false);
                SetActive((Enum)UI.STR_QUEST_NON_LIST, true);
            }
            else
            {
                SetActive((Enum)UI.STR_QUEST_NON_LIST, false);
                SetActive((Enum)UI.GRD_QUEST, true);
                SetDynamicList((Enum)UI.GRD_QUEST, "QuestListItem", questInfo.Length, false, (Func <int, bool>) null, (Func <int, Transform, Transform>) null, (Action <int, Transform, bool>) delegate(int i, Transform t, bool is_recycle)
                {
                    QuestSpecialSelect questSpecialSelect = this;
                    SetEvent(t, "SELECT_QUEST", i);
                    QuestInfoData info = questInfo[i];
                    int num5           = (int)(info.questData.tableData.difficulty + 1);
                    int j = 0;
                    for (int num6 = difficult.Length; j < num6; j++)
                    {
                        SetActive(t, difficult[j], j < num5);
                    }
                    if (!is_recycle)
                    {
                        ResetTween(t, UI.TWN_DIFFICULT_STAR, 0);
                        PlayTween(t, UI.TWN_DIFFICULT_STAR, true, null, false, 0);
                    }
                    EnemyTable.EnemyData enemyData = Singleton <EnemyTable> .I.GetEnemyData((uint)info.questData.tableData.GetMainEnemyID());
                    if (enemyData != null)
                    {
                        SetActive(t, UI.OBJ_ENEMY, true);
                        int iconId         = enemyData.iconId;
                        RARITY_TYPE?rarity = (info.questData.tableData.questType != QUEST_TYPE.ORDER) ? null : new RARITY_TYPE?(info.questData.tableData.rarity);
                        ItemIcon itemIcon  = ItemIcon.Create(ITEM_ICON_TYPE.QUEST_ITEM, iconId, rarity, FindCtrl(t, UI.OBJ_ENEMY), enemyData.element, null, -1, null, 0, false, -1, false, null, false, 0, 0, false, GET_TYPE.PAY);
                        itemIcon.SetEnableCollider(false);
                        SetActive(t, UI.SPR_ELEMENT_ROOT, enemyData.element != ELEMENT_TYPE.MAX);
                        SetElementSprite(t, UI.SPR_ELEMENT, (int)enemyData.element);
                        SetElementSprite(t, UI.SPR_WEAK_ELEMENT, (int)enemyData.weakElement);
                        SetActive(t, UI.STR_NON_WEAK_ELEMENT, enemyData.weakElement == ELEMENT_TYPE.MAX);
                    }
                    else
                    {
                        SetActive(t, UI.OBJ_ENEMY, false);
                        SetElementSprite(t, UI.SPR_WEAK_ELEMENT, 6);
                        SetActive(t, UI.STR_NON_WEAK_ELEMENT, true);
                    }
                    SetLabelText(t, UI.LBL_QUEST_NUM, string.Empty);
                    SetLabelText(t, UI.LBL_QUEST_NAME, info.questData.tableData.questText);
                    if (!info.isExistMission)
                    {
                        SetActive(t, UI.OBJ_MISSION_INFO_ROOT, false);
                    }
                    else
                    {
                        SetActive(t, UI.OBJ_MISSION_INFO_ROOT, true);
                        int k = 0;
                        for (int num7 = info.missionData.Length; k < num7; k++)
                        {
                            SetActive(t, ui_top_crown[k], info.missionData[k] != null);
                            if (info.missionData[k] != null)
                            {
                                SetActive(t, ui_crown[k], info.missionData[k].state >= CLEAR_STATUS.CLEAR);
                            }
                        }
                    }
                    int num8 = 1;
                    ClearStatusQuest clearStatusQuest = MonoBehaviourSingleton <QuestManager> .I.clearStatusQuest.Find((ClearStatusQuest data) => info.questData.tableData.questID == data.questId);
                    if (clearStatusQuest != null)
                    {
                        num8 = clearStatusQuest.questStatus;
                    }
                    int value = i + 100;
                    SetToggleGroup(t, UI.OBJ_ICON_NEW, value);
                    SetToggleGroup(t, UI.OBJ_ICON_CLEARED, value);
                    SetToggleGroup(t, UI.OBJ_ICON_COMPLETE, value);
                    switch (num8)
                    {
                    default:
                        SetToggle(t, UI.OBJ_ICON_NEW, false);
                        SetToggle(t, UI.OBJ_ICON_CLEARED, false);
                        SetToggle(t, UI.OBJ_ICON_COMPLETE, false);
                        break;

                    case 1:
                        SetToggle(t, UI.OBJ_ICON_NEW, true);
                        SetVisibleWidgetEffect(UI.SCR_NORMAL_QUEST, t, UI.SPR_ICON_NEW, "ef_ui_questselect_new");
                        break;

                    case 3:
                        SetToggle(t, UI.OBJ_ICON_CLEARED, true);
                        break;

                    case 4:
                        SetToggle(t, UI.OBJ_ICON_COMPLETE, true);
                        SetVisibleWidgetEffect(UI.SCR_NORMAL_QUEST, t, UI.SPR_ICON_COMPLETE, "ef_ui_questselect_complete");
                        break;
                    }
                });
            }
        }
    }