Example #1
0
        public static string ItemIcon(ItemParam param)
        {
            if (param != null)
            {
                switch (param.type)
                {
                case EItemType.ArtifactPiece:
                    if (!string.IsNullOrEmpty((string)param.icon))
                    {
                        AssetPath.mSB.Length = 0;
                        AssetPath.mSB.Append("ArtiIcon/");
                        AssetPath.mSB.Append((string)param.icon);
                        return(AssetPath.mSB.ToString());
                    }
                    break;

                case EItemType.Unit:
                    if (!string.IsNullOrEmpty((string)param.icon))
                    {
                        UnitParam unitParam = MonoSingleton <GameManager> .Instance.MasterParam.GetUnitParam(param.iname);

                        if (unitParam != null)
                        {
                            return(AssetPath.UnitIconSmall(unitParam, unitParam.GetJobId(0)));
                        }
                        break;
                    }
                    break;

                default:
                    return(AssetPath.ItemIcon((string)param.icon));
                }
            }
            return((string)null);
        }
Example #2
0
        public override void UpdateValue()
        {
            ItemParam itemParam;
            int       itemNum;

            this.InstanceType.GetInstanceData(this.InstanceIndex, ((Component)this).get_gameObject(), out itemParam, out itemNum);
            if (itemParam == null)
            {
                return;
            }
            if (Object.op_Inequality((Object)this.Icon, (Object)null))
            {
                MonoSingleton <GameManager> .Instance.ApplyTextureAsync(this.Icon, AssetPath.ItemIcon(itemParam));
            }
            if (Object.op_Inequality((Object)this.Frame, (Object)null))
            {
                this.Frame.set_sprite(GameSettings.Instance.GetItemFrame(itemParam));
            }
            if (Object.op_Inequality((Object)this.Num, (Object)null))
            {
                this.Num.set_text(itemNum.ToString());
            }
            if (!Object.op_Inequality((Object)this.NumSlider, (Object)null))
            {
                return;
            }
            this.NumSlider.set_value((float)itemNum / (float)(int)itemParam.cap);
        }
Example #3
0
 private string GetIconPath(ItemParam param)
 {
     if (param == null)
     {
         return((string)null);
     }
     return(AssetPath.ItemIcon(param));
 }
Example #4
0
 private string GetIconPath(ItemParam param, bool isSecret)
 {
     if (isSecret)
     {
         return(this.GetSecretIconPath());
     }
     if (param == null)
     {
         return(string.Empty);
     }
     return(AssetPath.ItemIcon(param));
 }
        public string GetIconPath()
        {
            switch (this.reward_type)
            {
            case eRewardType.Item:
                return(AssetPath.ItemIcon(MonoSingleton <GameManager> .Instance.GetItemParam(this.iname)));

            case eRewardType.Artifact:
                return(AssetPath.ArtifactIcon(MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(this.iname)));

            case eRewardType.ConceptCard:
                return(AssetPath.ConceptCardIcon(MonoSingleton <GameManager> .Instance.MasterParam.GetConceptCardParam(this.iname)));

            default:
                return(string.Empty);
            }
        }
Example #6
0
 public static string ItemIcon(ItemParam param)
 {
     if (param != null)
     {
         if (param.type != EItemType.ArtifactPiece)
         {
             return(AssetPath.ItemIcon((string)param.icon));
         }
         if (!string.IsNullOrEmpty((string)param.icon))
         {
             AssetPath.mSB.Length = 0;
             AssetPath.mSB.Append("ArtiIcon/");
             AssetPath.mSB.Append((string)param.icon);
             return(AssetPath.mSB.ToString());
         }
     }
     return((string)null);
 }
Example #7
0
        public void SetData(VersusTowerRewardItem.REWARD_TYPE type, int idx = 0)
        {
            GameManager      instance    = MonoSingleton <GameManager> .Instance;
            VersusTowerParam dataOfClass = DataSource.FindDataOfClass <VersusTowerParam>(((Component)this).get_gameObject(), (VersusTowerParam)null);
            int versusTowerFloor         = instance.Player.VersusTowerFloor;

            if (dataOfClass == null)
            {
                return;
            }
            VERSUS_ITEM_TYPE versusItemType = VERSUS_ITEM_TYPE.item;
            string           str            = string.Empty;
            int num = 0;

            if (type == VersusTowerRewardItem.REWARD_TYPE.Arrival)
            {
                versusItemType = dataOfClass.ArrivalItemType;
                str            = (string)dataOfClass.ArrivalIteminame;
                num            = (int)dataOfClass.ArrivalItemNum;
            }
            else if (idx >= 0 && idx < dataOfClass.SeasonIteminame.Length)
            {
                versusItemType = dataOfClass.SeasonItemType[idx];
                str            = (string)dataOfClass.SeasonIteminame[idx];
                num            = (int)dataOfClass.SeasonItemnum[idx];
            }
            if (Object.op_Inequality((Object)this.itemObj, (Object)null))
            {
                this.itemObj.SetActive(true);
            }
            if (Object.op_Inequality((Object)this.amountObj, (Object)null))
            {
                this.amountObj.SetActive(true);
            }
            if (Object.op_Inequality((Object)this.unitObj, (Object)null))
            {
                this.unitObj.SetActive(false);
            }
            switch (versusItemType)
            {
            case VERSUS_ITEM_TYPE.item:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null) && Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(false);
                    }
                    this.itemObj.SetActive(true);
                    DataSource component1 = (DataSource)this.itemObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component1, (Object)null))
                    {
                        component1.Clear();
                    }
                    DataSource component2 = (DataSource)this.amountObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component2, (Object)null))
                    {
                        component2.Clear();
                    }
                    ItemParam itemParam = instance.GetItemParam(str);
                    DataSource.Bind <ItemParam>(this.itemObj, itemParam);
                    ItemData data = new ItemData();
                    data.Setup(0L, itemParam, num);
                    DataSource.Bind <ItemData>(this.amountObj, data);
                    Transform child = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child, (Object)null))
                    {
                        GameParameter component3 = (GameParameter)((Component)child).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(true);
                        }
                    }
                    GameParameter.UpdateAll(this.itemObj);
                    if (Object.op_Inequality((Object)this.iconParam, (Object)null))
                    {
                        this.iconParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.frameParam, (Object)null))
                    {
                        this.frameParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(itemParam.name + string.Format(LocalizedText.Get("sys.CROSS_NUM"), (object)num));
                        break;
                    }
                    break;
                }
                break;

            case VERSUS_ITEM_TYPE.gold:
                if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                {
                    GameParameter component = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        ((Behaviour)component).set_enabled(false);
                    }
                    this.itemTex.set_texture(this.goldTex);
                }
                if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.goldBase, (Object)null))
                {
                    this.frameTex.set_sprite(this.goldBase);
                }
                if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    this.rewardName.set_text(num.ToString() + LocalizedText.Get("sys.GOLD"));
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(false);
                    break;
                }
                break;

            case VERSUS_ITEM_TYPE.coin:
                if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                {
                    GameParameter component = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        ((Behaviour)component).set_enabled(false);
                    }
                    this.itemTex.set_texture(this.coinTex);
                }
                if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                {
                    this.frameTex.set_sprite(this.coinBase);
                }
                if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    this.rewardName.set_text(string.Format(LocalizedText.Get("sys.CHALLENGE_REWARD_COIN"), (object)num));
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(false);
                    break;
                }
                break;

            case VERSUS_ITEM_TYPE.unit:
                if (Object.op_Inequality((Object)this.unitObj, (Object)null))
                {
                    if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                    {
                        this.itemObj.SetActive(false);
                    }
                    this.unitObj.SetActive(true);
                    UnitParam unitParam = instance.GetUnitParam(str);
                    DebugUtility.Assert(unitParam != null, "Invalid unit:" + str);
                    UnitData data = new UnitData();
                    data.Setup(str, 0, 1, 0, (string)null, 1, EElement.None, 0);
                    DataSource.Bind <UnitData>(this.unitObj, data);
                    GameParameter.UpdateAll(this.unitObj);
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_UNIT"), (object)unitParam.name));
                        break;
                    }
                    break;
                }
                break;

            case VERSUS_ITEM_TYPE.artifact:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                {
                    DataSource component = (DataSource)this.itemObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        component.Clear();
                    }
                    ArtifactParam artifactParam = instance.MasterParam.GetArtifactParam(str);
                    DataSource.Bind <ArtifactParam>(this.itemObj, artifactParam);
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(true);
                        componentInChildren.UpdateValue();
                        if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                        {
                            this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_ARTIFACT"), (object)artifactParam.name));
                        }
                        if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                        {
                            this.amountObj.SetActive(false);
                            break;
                        }
                        break;
                    }
                    break;
                }
                break;

            case VERSUS_ITEM_TYPE.award:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null) && Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(false);
                    }
                    this.itemObj.SetActive(true);
                    AwardParam awardParam = instance.GetAwardParam(str);
                    Transform  child      = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child, (Object)null))
                    {
                        IconLoader iconLoader = GameUtility.RequireComponent <IconLoader>(((Component)child).get_gameObject());
                        if (!string.IsNullOrEmpty(awardParam.icon))
                        {
                            iconLoader.ResourcePath = AssetPath.ItemIcon(awardParam.icon);
                        }
                        GameParameter component = (GameParameter)((Component)child).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component, (Object)null))
                        {
                            ((Behaviour)component).set_enabled(false);
                        }
                    }
                    if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                    {
                        this.frameTex.set_sprite(this.coinBase);
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                        break;
                    }
                    break;
                }
                break;
            }
            this.mType      = type;
            this.mSeasonIdx = idx;
            if (type == VersusTowerRewardItem.REWARD_TYPE.Arrival)
            {
                if (Object.op_Inequality((Object)this.currentMark, (Object)null))
                {
                    this.currentMark.SetActive((int)dataOfClass.Floor - 1 == versusTowerFloor);
                }
                if (Object.op_Inequality((Object)this.current_fil, (Object)null))
                {
                    this.current_fil.SetActive((int)dataOfClass.Floor - 1 == versusTowerFloor);
                }
            }
            else
            {
                if (Object.op_Inequality((Object)this.currentMark, (Object)null))
                {
                    this.currentMark.SetActive((int)dataOfClass.Floor == versusTowerFloor);
                }
                if (Object.op_Inequality((Object)this.current_fil, (Object)null))
                {
                    this.current_fil.SetActive((int)dataOfClass.Floor == versusTowerFloor);
                }
            }
            if (Object.op_Inequality((Object)this.clearMark, (Object)null))
            {
                this.clearMark.SetActive((int)dataOfClass.Floor - 1 < versusTowerFloor);
            }
            if (!Object.op_Inequality((Object)this.cleared_fil, (Object)null))
            {
                return;
            }
            this.cleared_fil.SetActive((int)dataOfClass.Floor - 1 < versusTowerFloor);
        }
Example #8
0
        public override void UpdateValue()
        {
            KeyItem dataOfClass1 = DataSource.FindDataOfClass <KeyItem>(((Component)this).get_gameObject(), (KeyItem)null);

            if (dataOfClass1 != null)
            {
                ItemParam itemParam = MonoSingleton <GameManager> .Instance.GetItemParam(dataOfClass1.iname);

                if (itemParam != null)
                {
                    ItemData itemDataByItemParam = MonoSingleton <GameManager> .Instance.Player.FindItemDataByItemParam(itemParam);

                    int num = itemDataByItemParam == null ? 0 : itemDataByItemParam.Num;
                    if (Object.op_Inequality((Object)this.Icon, (Object)null))
                    {
                        MonoSingleton <GameManager> .Instance.ApplyTextureAsync(this.Icon, AssetPath.ItemIcon(itemParam));
                    }
                    if (Object.op_Inequality((Object)this.Frame, (Object)null))
                    {
                        this.Frame.set_sprite(GameSettings.Instance.GetItemFrame(itemParam));
                    }
                    if (Object.op_Inequality((Object)this.UseNum, (Object)null))
                    {
                        this.UseNum.set_text(dataOfClass1.num.ToString());
                    }
                    if (Object.op_Inequality((Object)this.Amount, (Object)null))
                    {
                        this.Amount.set_text(num.ToString());
                    }
                    if (Object.op_Inequality((Object)this.Locked, (Object)null))
                    {
                        ChapterParam dataOfClass2 = DataSource.FindDataOfClass <ChapterParam>(((Component)this).get_gameObject(), (ChapterParam)null);
                        this.Locked.SetActive(dataOfClass2 == null || !dataOfClass2.IsKeyQuest() || !dataOfClass2.IsKeyUnlock(Network.GetServerTime()));
                    }
                }
            }
            if (Object.op_Inequality((Object)this.QuestTimer, (Object)null))
            {
                this.QuestTimer.UpdateValue();
            }
            if (!Object.op_Inequality((Object)this.IconRoot, (Object)null) || !Object.op_Inequality((Object)this.Locked, (Object)null))
            {
                return;
            }
            this.IconRoot.SetActive(this.Locked.get_activeSelf());
        }
 public void Refresh()
 {
     if (this.m_Present == null)
     {
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_TimeLimitObject, (UnityEngine.Object)null))
         {
             this.m_TimeLimitObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NameObject, (UnityEngine.Object)null))
         {
             this.m_NameObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_IconObject, (UnityEngine.Object)null))
         {
             this.m_IconObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_CoinIconObject, (UnityEngine.Object)null))
         {
             this.m_CoinIconObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NumObject, (UnityEngine.Object)null))
         {
             this.m_NumObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_SettingTextObject, (UnityEngine.Object)null))
         {
             this.m_SettingTextObject.SetActive(true);
         }
         if (!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_FrameObject, (UnityEngine.Object)null))
         {
             return;
         }
         this.SetSprite(this.m_FrameObject, GameSettings.Instance.GetItemFrame(EItemType.Other, 0), Color.get_gray());
     }
     else
     {
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_SettingTextObject, (UnityEngine.Object)null))
         {
             this.m_SettingTextObject.SetActive(false);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_TimeLimitObject, (UnityEngine.Object)null))
         {
             this.m_TimeLimitObject.SetActive(this.m_Present.HasTimeLimit());
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_TimeLimitValueObject, (UnityEngine.Object)null))
         {
             this.SetRestTime(this.m_TimeLimitValueObject, this.m_Present.end_at);
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NameObject, (UnityEngine.Object)null))
         {
             this.SetText(this.m_NameObject, this.m_Present.name);
         }
         if (this.m_ItemData != null)
         {
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_FrameObject, (UnityEngine.Object)null))
             {
                 this.SetSprite(this.m_FrameObject, GameSettings.Instance.GetItemFrame(this.m_Present.item), Color.get_white());
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_IconObject, (UnityEngine.Object)null))
             {
                 this.m_IconObject.SetActive(true);
                 GameUtility.RequireComponent <IconLoader>(this.m_IconObject).ResourcePath = AssetPath.ItemIcon(this.m_ItemData.Param);
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_CoinIconObject, (UnityEngine.Object)null))
             {
                 this.m_CoinIconObject.SetActive(false);
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_AmountObject, (UnityEngine.Object)null))
             {
                 this.SetText(this.m_AmountObject, this.m_Present.num);
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NumObject, (UnityEngine.Object)null))
             {
                 this.m_NumObject.SetActive(true);
             }
             if (!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NumValueObject, (UnityEngine.Object)null))
             {
                 return;
             }
             this.m_NumValueObject.SetActive(true);
             this.SetText(this.m_NumValueObject, this.m_ItemData.Num);
         }
         else
         {
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_FrameObject, (UnityEngine.Object)null))
             {
                 this.SetSprite(this.m_FrameObject, GameSettings.Instance.GetItemFrame(EItemType.Other, 0), Color.get_white());
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_IconObject, (UnityEngine.Object)null))
             {
                 this.m_IconObject.SetActive(false);
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_CoinIconObject, (UnityEngine.Object)null))
             {
                 this.m_CoinIconObject.SetActive(true);
             }
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_ZenyObject, (UnityEngine.Object)null))
             {
                 this.SetText(this.m_ZenyObject, this.m_Present.zeny);
             }
             if (!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_NumObject, (UnityEngine.Object)null))
             {
                 return;
             }
             this.m_NumObject.SetActive(false);
         }
     }
 }
        public void SetData(int idx = 0)
        {
            GameManager          instance    = MonoSingleton <GameManager> .Instance;
            MultiTowerFloorParam dataOfClass = DataSource.FindDataOfClass <MultiTowerFloorParam>(((Component)this).get_gameObject(), (MultiTowerFloorParam)null);
            int floor = (int)dataOfClass.floor;

            if (dataOfClass == null)
            {
                return;
            }
            int mtRound = MonoSingleton <GameManager> .Instance.GetMTRound(GlobalVars.SelectedMultiTowerFloor);

            List <MultiTowerRewardItem> mtFloorReward        = instance.GetMTFloorReward(dataOfClass.reward_id, mtRound);
            MultiTowerRewardItem        multiTowerRewardItem = mtFloorReward[idx];

            MultiTowerRewardItem.RewardType rewardType = MultiTowerRewardItem.RewardType.Item;
            string str = string.Empty;
            int    num = 0;

            if (idx >= 0 && idx < mtFloorReward.Count)
            {
                rewardType = multiTowerRewardItem.type;
                str        = multiTowerRewardItem.itemname;
                num        = multiTowerRewardItem.num;
            }
            if (Object.op_Inequality((Object)this.itemObj, (Object)null))
            {
                this.itemObj.SetActive(true);
            }
            if (Object.op_Inequality((Object)this.amountObj, (Object)null))
            {
                this.amountObj.SetActive(true);
            }
            if (Object.op_Inequality((Object)this.unitObj, (Object)null))
            {
                this.unitObj.SetActive(false);
            }
            switch (rewardType)
            {
            case MultiTowerRewardItem.RewardType.Item:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null) && Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(false);
                    }
                    this.itemObj.SetActive(true);
                    DataSource component1 = (DataSource)this.itemObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component1, (Object)null))
                    {
                        component1.Clear();
                    }
                    DataSource component2 = (DataSource)this.amountObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component2, (Object)null))
                    {
                        component2.Clear();
                    }
                    ItemParam itemParam = instance.GetItemParam(str);
                    DataSource.Bind <ItemParam>(this.itemObj, itemParam);
                    ItemData data = new ItemData();
                    data.Setup(0L, itemParam, num);
                    DataSource.Bind <ItemData>(this.amountObj, data);
                    Transform child = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child, (Object)null))
                    {
                        GameParameter component3 = (GameParameter)((Component)child).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(true);
                        }
                    }
                    GameParameter.UpdateAll(this.itemObj);
                    if (Object.op_Inequality((Object)this.iconParam, (Object)null))
                    {
                        this.iconParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.frameParam, (Object)null))
                    {
                        this.frameParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(itemParam.name + string.Format(LocalizedText.Get("sys.CROSS_NUM"), (object)num));
                        break;
                    }
                    break;
                }
                break;

            case MultiTowerRewardItem.RewardType.Coin:
                if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                {
                    GameParameter component = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        ((Behaviour)component).set_enabled(false);
                    }
                    this.itemTex.set_texture(this.coinTex);
                }
                if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                {
                    this.frameTex.set_sprite(this.coinBase);
                }
                if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    this.rewardName.set_text(string.Format(LocalizedText.Get("sys.CHALLENGE_REWARD_COIN"), (object)num));
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(false);
                    break;
                }
                break;

            case MultiTowerRewardItem.RewardType.Artifact:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                {
                    DataSource component = (DataSource)this.itemObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        component.Clear();
                    }
                    ArtifactParam artifactParam = instance.MasterParam.GetArtifactParam(str);
                    DataSource.Bind <ArtifactParam>(this.itemObj, artifactParam);
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(true);
                        componentInChildren.UpdateValue();
                        if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                        {
                            this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_ARTIFACT"), (object)artifactParam.name));
                        }
                        if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                        {
                            this.amountObj.SetActive(false);
                            break;
                        }
                        break;
                    }
                    break;
                }
                break;

            case MultiTowerRewardItem.RewardType.Award:
                if (Object.op_Inequality((Object)this.itemObj, (Object)null) && Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.itemObj.GetComponentInChildren <ArtifactIcon>();
                    if (Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        ((Behaviour)componentInChildren).set_enabled(false);
                    }
                    this.itemObj.SetActive(true);
                    AwardParam awardParam = instance.GetAwardParam(str);
                    Transform  child      = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child, (Object)null))
                    {
                        IconLoader iconLoader = GameUtility.RequireComponent <IconLoader>(((Component)child).get_gameObject());
                        if (!string.IsNullOrEmpty(awardParam.icon))
                        {
                            iconLoader.ResourcePath = AssetPath.ItemIcon(awardParam.icon);
                        }
                        GameParameter component = (GameParameter)((Component)child).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component, (Object)null))
                        {
                            ((Behaviour)component).set_enabled(false);
                        }
                    }
                    if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                    {
                        this.frameTex.set_sprite(this.coinBase);
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                        break;
                    }
                    break;
                }
                break;

            case MultiTowerRewardItem.RewardType.Unit:
                if (Object.op_Inequality((Object)this.unitObj, (Object)null))
                {
                    if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                    {
                        this.itemObj.SetActive(false);
                    }
                    this.unitObj.SetActive(true);
                    UnitParam unitParam = instance.GetUnitParam(str);
                    DebugUtility.Assert(unitParam != null, "Invalid unit:" + str);
                    UnitData data = new UnitData();
                    data.Setup(str, 0, 1, 0, (string)null, 1, EElement.None, 0);
                    DataSource.Bind <UnitData>(this.unitObj, data);
                    GameParameter.UpdateAll(this.unitObj);
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_UNIT"), (object)unitParam.name));
                        break;
                    }
                    break;
                }
                break;

            case MultiTowerRewardItem.RewardType.Gold:
                if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                {
                    GameParameter component = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        ((Behaviour)component).set_enabled(false);
                    }
                    this.itemTex.set_texture(this.goldTex);
                }
                if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.goldBase, (Object)null))
                {
                    this.frameTex.set_sprite(this.goldBase);
                }
                if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    this.rewardName.set_text(num.ToString() + LocalizedText.Get("sys.GOLD"));
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(false);
                    break;
                }
                break;
            }
            this.mIdx = idx;
            if (Object.op_Inequality((Object)this.currentMark, (Object)null))
            {
                this.currentMark.SetActive((int)dataOfClass.floor == floor);
            }
            if (Object.op_Inequality((Object)this.current_fil, (Object)null))
            {
                this.current_fil.SetActive((int)dataOfClass.floor == floor);
            }
            if (Object.op_Inequality((Object)this.clearMark, (Object)null))
            {
                this.clearMark.SetActive((int)dataOfClass.floor - 1 < floor);
            }
            if (!Object.op_Inequality((Object)this.cleared_fil, (Object)null))
            {
                return;
            }
            this.cleared_fil.SetActive((int)dataOfClass.floor - 1 < floor);
        }
Example #11
0
 private string GetSecretIconPath()
 {
     return(AssetPath.ItemIcon("IT_UNKNOWN"));
 }
Example #12
0
        private void SetData()
        {
            GameManager          instance    = MonoSingleton <GameManager> .Instance;
            MultiTowerRewardItem dataOfClass = DataSource.FindDataOfClass <MultiTowerRewardItem>(((Component)this).get_gameObject(), (MultiTowerRewardItem)null);

            if (dataOfClass == null)
            {
                if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                {
                    this.itemObj.SetActive(false);
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(false);
                }
                if (Object.op_Inequality((Object)this.unitObj, (Object)null))
                {
                    this.unitObj.SetActive(false);
                }
                if (!Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    return;
                }
                ((Component)this.rewardName).get_gameObject().SetActive(false);
            }
            else
            {
                MultiTowerRewardItem.RewardType type = dataOfClass.type;
                string itemname = dataOfClass.itemname;
                int    num      = dataOfClass.num;
                if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                {
                    this.itemObj.SetActive(true);
                }
                if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                {
                    this.amountObj.SetActive(true);
                }
                if (Object.op_Inequality((Object)this.unitObj, (Object)null))
                {
                    this.unitObj.SetActive(false);
                }
                if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                {
                    ((Component)this.rewardName).get_gameObject().SetActive(true);
                }
                switch (type)
                {
                case MultiTowerRewardItem.RewardType.Item:
                    if (Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        this.artifactObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.itemObj, (Object)null) || !Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        break;
                    }
                    this.itemObj.SetActive(true);
                    DataSource component1 = (DataSource)this.itemObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component1, (Object)null))
                    {
                        component1.Clear();
                    }
                    DataSource component2 = (DataSource)this.amountObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component2, (Object)null))
                    {
                        component2.Clear();
                    }
                    ItemParam itemParam = instance.GetItemParam(itemname);
                    DataSource.Bind <ItemParam>(this.itemObj, itemParam);
                    ItemData data1 = new ItemData();
                    data1.Setup(0L, itemParam, num);
                    DataSource.Bind <ItemData>(this.amountObj, data1);
                    Transform child1 = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child1, (Object)null))
                    {
                        GameParameter component3 = (GameParameter)((Component)child1).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(true);
                        }
                    }
                    GameParameter.UpdateAll(this.itemObj);
                    if (Object.op_Inequality((Object)this.iconParam, (Object)null))
                    {
                        this.iconParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.frameParam, (Object)null))
                    {
                        this.frameParam.UpdateValue();
                    }
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(itemParam.name + string.Format(LocalizedText.Get("sys.CROSS_NUM"), (object)num));
                    }
                    if (!Object.op_Inequality((Object)this.amountOther, (Object)null))
                    {
                        break;
                    }
                    this.amountOther.SetActive(false);
                    break;

                case MultiTowerRewardItem.RewardType.Coin:
                    if (Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        this.artifactObj.SetActive(false);
                    }
                    if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                    {
                        GameParameter component3 = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(false);
                        }
                        this.itemTex.set_texture(this.coinTex);
                    }
                    if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                    {
                        this.frameTex.set_sprite(this.coinBase);
                    }
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(string.Format(LocalizedText.Get("sys.CHALLENGE_REWARD_COIN"), (object)num));
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.amountOther, (Object)null))
                    {
                        break;
                    }
                    if (this.amountDisp)
                    {
                        this.amountOther.SetActive(true);
                        if (!Object.op_Inequality((Object)this.amountCount, (Object)null))
                        {
                            break;
                        }
                        this.amountCount.set_text(dataOfClass.num.ToString());
                        break;
                    }
                    this.amountOther.SetActive(false);
                    break;

                case MultiTowerRewardItem.RewardType.Artifact:
                    if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                    {
                        this.itemObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        break;
                    }
                    this.artifactObj.SetActive(true);
                    DataSource component4 = (DataSource)this.artifactObj.GetComponent <DataSource>();
                    if (Object.op_Inequality((Object)component4, (Object)null))
                    {
                        component4.Clear();
                    }
                    ArtifactParam artifactParam = instance.MasterParam.GetArtifactParam(itemname);
                    DataSource.Bind <ArtifactParam>(this.artifactObj, artifactParam);
                    ArtifactIcon componentInChildren = (ArtifactIcon)this.artifactObj.GetComponentInChildren <ArtifactIcon>();
                    if (!Object.op_Inequality((Object)componentInChildren, (Object)null))
                    {
                        break;
                    }
                    ((Behaviour)componentInChildren).set_enabled(true);
                    componentInChildren.UpdateValue();
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_ARTIFACT"), (object)artifactParam.name));
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.Artifactamount, (Object)null))
                    {
                        break;
                    }
                    this.Artifactamount.set_text(dataOfClass.num.ToString());
                    break;

                case MultiTowerRewardItem.RewardType.Award:
                    if (Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        this.artifactObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.itemObj, (Object)null) || !Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        break;
                    }
                    this.itemObj.SetActive(true);
                    AwardParam awardParam = instance.GetAwardParam(itemname);
                    Transform  child2     = this.itemObj.get_transform().FindChild("icon");
                    if (Object.op_Inequality((Object)child2, (Object)null))
                    {
                        IconLoader iconLoader = GameUtility.RequireComponent <IconLoader>(((Component)child2).get_gameObject());
                        if (!string.IsNullOrEmpty(awardParam.icon))
                        {
                            iconLoader.ResourcePath = AssetPath.ItemIcon(awardParam.icon);
                        }
                        GameParameter component3 = (GameParameter)((Component)child2).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(false);
                        }
                        if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                        {
                            this.rewardName.set_text(awardParam.name);
                        }
                    }
                    if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.coinBase, (Object)null))
                    {
                        this.frameTex.set_sprite(this.coinBase);
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.amountOther, (Object)null))
                    {
                        break;
                    }
                    this.amountOther.SetActive(false);
                    break;

                case MultiTowerRewardItem.RewardType.Unit:
                    if (!Object.op_Inequality((Object)this.unitObj, (Object)null))
                    {
                        break;
                    }
                    if (Object.op_Inequality((Object)this.itemObj, (Object)null))
                    {
                        this.itemObj.SetActive(false);
                    }
                    if (Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        this.artifactObj.SetActive(false);
                    }
                    this.unitObj.SetActive(true);
                    UnitParam unitParam = instance.GetUnitParam(itemname);
                    DebugUtility.Assert(unitParam != null, "Invalid unit:" + itemname);
                    UnitData data2 = new UnitData();
                    data2.Setup(itemname, 0, 1, 0, (string)null, 1, EElement.None, 0);
                    DataSource.Bind <UnitData>(this.unitObj, data2);
                    GameParameter.UpdateAll(this.unitObj);
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(string.Format(LocalizedText.Get("sys.MULTI_VERSUS_REWARD_UNIT"), (object)unitParam.name));
                    }
                    if (!Object.op_Inequality((Object)this.amountOther, (Object)null))
                    {
                        break;
                    }
                    this.amountOther.SetActive(false);
                    break;

                case MultiTowerRewardItem.RewardType.Gold:
                    if (Object.op_Inequality((Object)this.artifactObj, (Object)null))
                    {
                        this.artifactObj.SetActive(false);
                    }
                    if (Object.op_Inequality((Object)this.itemTex, (Object)null))
                    {
                        GameParameter component3 = (GameParameter)((Component)this.itemTex).GetComponent <GameParameter>();
                        if (Object.op_Inequality((Object)component3, (Object)null))
                        {
                            ((Behaviour)component3).set_enabled(false);
                        }
                        this.itemTex.set_texture(this.goldTex);
                    }
                    if (Object.op_Inequality((Object)this.frameTex, (Object)null) && Object.op_Inequality((Object)this.goldBase, (Object)null))
                    {
                        this.frameTex.set_sprite(this.goldBase);
                    }
                    if (Object.op_Inequality((Object)this.rewardName, (Object)null))
                    {
                        this.rewardName.set_text(num.ToString() + LocalizedText.Get("sys.GOLD"));
                    }
                    if (Object.op_Inequality((Object)this.amountObj, (Object)null))
                    {
                        this.amountObj.SetActive(false);
                    }
                    if (!Object.op_Inequality((Object)this.amountOther, (Object)null))
                    {
                        break;
                    }
                    if (this.amountDisp)
                    {
                        this.amountOther.SetActive(true);
                        if (!Object.op_Inequality((Object)this.amountCount, (Object)null))
                        {
                            break;
                        }
                        this.amountCount.set_text(dataOfClass.num.ToString());
                        break;
                    }
                    this.amountOther.SetActive(false);
                    break;
                }
            }
        }
Example #13
0
        public override void UpdateValue()
        {
            ItemParam itemParam;
            int       itemNum;

            this.InstanceType.GetInstanceData(this.InstanceIndex, ((Component)this).get_gameObject(), out itemParam, out itemNum);
            if (itemParam == null)
            {
                return;
            }
            this.mSecretItemParam = itemParam;
            if (Object.op_Inequality((Object)this.Icon, (Object)null))
            {
                if (this.IsSecret)
                {
                    MonoSingleton <GameManager> .Instance.ApplyTextureAsync(this.Icon, AssetPath.ItemIcon("IT_UNKNOWN"));

                    if (Object.op_Implicit((Object)this.SecretAmount))
                    {
                        this.SecretAmount.SetActive(false);
                    }
                    if (Object.op_Implicit((Object)this.SecretBadge))
                    {
                        ((Behaviour)this.SecretBadge).set_enabled(false);
                    }
                }
                else
                {
                    MonoSingleton <GameManager> .Instance.ApplyTextureAsync(this.Icon, AssetPath.ItemIcon(itemParam));
                }
            }
            if (Object.op_Inequality((Object)this.Frame, (Object)null))
            {
                if (this.IsSecret)
                {
                    if (GameSettings.Instance.ItemIcons.NormalFrames != null && GameSettings.Instance.ItemIcons.NormalFrames.Length != 0)
                    {
                        this.Frame.set_sprite(GameSettings.Instance.ItemIcons.NormalFrames[0]);
                    }
                }
                else
                {
                    this.Frame.set_sprite(GameSettings.Instance.GetItemFrame(itemParam));
                }
            }
            if (Object.op_Inequality((Object)this.Num, (Object)null))
            {
                this.Num.set_text(itemNum.ToString());
            }
            if (Object.op_Inequality((Object)this.NumSlider, (Object)null))
            {
                this.NumSlider.set_value((float)itemNum / (float)itemParam.cap);
            }
            if (!Object.op_Inequality((Object)this.HaveNum, (Object)null))
            {
                return;
            }
            int num = -1;

            if (itemParam.iname == "$COIN")
            {
                num = MonoSingleton <GameManager> .Instance.Player.Coin;
            }
            else
            {
                ItemData itemDataByItemParam = MonoSingleton <GameManager> .Instance.Player.FindItemDataByItemParam(itemParam);

                if (itemDataByItemParam != null)
                {
                    num = itemDataByItemParam.Num;
                }
            }
            if (num < 0)
            {
                return;
            }
            this.HaveNum.set_text(LocalizedText.Get("sys.QUESTRESULT_REWARD_ITEM_HAVE", new object[1]
            {
                (object)num
            }));
        }