Ejemplo n.º 1
0
        private void AddGemContents(BundleParam bundleInfo, bool isFreeGems = false)
        {
            GameObject gameObject = this.itemCount >= this.limited_shop_item_set_list.Count ? (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate) : ((Component)this.limited_shop_item_set_list[this.itemCount]).get_gameObject();

            if (Object.op_Inequality((Object)gameObject, (Object)null))
            {
                gameObject.SetActive(true);
                Vector3 localScale = gameObject.get_transform().get_localScale();
                gameObject.get_transform().SetParent(this.ItemParent.get_transform());
                gameObject.get_transform().set_localScale(localScale);
                LimitedShopSetItemListElement component = (LimitedShopSetItemListElement)gameObject.GetComponent <LimitedShopSetItemListElement>();
                ItemData      itemData      = new ItemData();
                StringBuilder stringBuilder = GameUtility.GetStringBuilder();
                if (isFreeGems)
                {
                    itemData.Setup(0L, "$COIN", bundleInfo.AdditionalFreeCoin);
                    stringBuilder.Append(LocalizedText.Get("sys.CONFIG_CHECKCOIN_FREE"));
                    stringBuilder.Append(" × ");
                    stringBuilder.Append(bundleInfo.AdditionalFreeCoin.ToString());
                }
                else
                {
                    itemData.Setup(0L, "$COIN", bundleInfo.AdditionalPaidCoin);
                    stringBuilder.Append(LocalizedText.Get("sys.CONFIG_CHECKCOIN_PAY"));
                    stringBuilder.Append(" × ");
                    stringBuilder.Append(bundleInfo.AdditionalPaidCoin.ToString());
                }
                component.itemName.set_text(stringBuilder.ToString());
                component.itemData = itemData;
                this.limited_shop_item_set_list.Add(component);
            }
            ++this.itemCount;
        }
Ejemplo n.º 2
0
        private void AddItemContents(BundleParam.BundleItemInfo itemInfo, bool isUnit = false)
        {
            GameObject gameObject = this.itemCount >= this.limited_shop_item_set_list.Count ? (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate) : ((Component)this.limited_shop_item_set_list[this.itemCount]).get_gameObject();

            if (Object.op_Inequality((Object)gameObject, (Object)null))
            {
                gameObject.SetActive(true);
                Vector3 localScale = gameObject.get_transform().get_localScale();
                gameObject.get_transform().SetParent(this.ItemParent.get_transform());
                gameObject.get_transform().set_localScale(localScale);
                LimitedShopSetItemListElement component = (LimitedShopSetItemListElement)gameObject.GetComponent <LimitedShopSetItemListElement>();
                ItemData itemData = new ItemData();
                itemData.Setup(0L, itemInfo.Name, itemInfo.Quantity);
                StringBuilder stringBuilder = GameUtility.GetStringBuilder();
                if (isUnit)
                {
                    UnitParam unitParam = MonoSingleton <GameManager> .Instance.GetUnitParam(itemInfo.Name);

                    stringBuilder.Append(unitParam.name);
                }
                else if (itemData != null)
                {
                    stringBuilder.Append(itemData.Param.name);
                }
                stringBuilder.Append(" × ");
                stringBuilder.Append(itemInfo.Quantity.ToString());
                component.itemName.set_text(stringBuilder.ToString());
                component.itemData = itemData;
                this.limited_shop_item_set_list.Add(component);
            }
            ++this.itemCount;
        }
        private ItemData CreateItemData(ItemParam iparam, int num)
        {
            ItemData itemData = new ItemData();

            itemData.Setup(0L, iparam, num);
            return(itemData);
        }
Ejemplo n.º 4
0
        public List <ItemData> GetReturnItemList()
        {
            if (!this.IsValid() || !this.IsEquiped())
            {
                return((List <ItemData>)null);
            }
            RarityEquipEnhanceParam equipEnhanceParam = this.RarityParam == null ? (RarityEquipEnhanceParam)null : this.RarityParam.EquipEnhanceParam;

            if (equipEnhanceParam == null || equipEnhanceParam.ranks == null)
            {
                return((List <ItemData>)null);
            }
            RarityEquipEnhanceParam.RankParam rankParam = equipEnhanceParam.GetRankParam(this.Rank);
            if (rankParam == null || rankParam.return_item == null)
            {
                return((List <ItemData>)null);
            }
            ReturnItem[]    returnItem   = rankParam.return_item;
            List <ItemData> itemDataList = new List <ItemData>();

            for (int index = 0; index < returnItem.Length; ++index)
            {
                if (!string.IsNullOrEmpty(returnItem[index].iname) && (int)returnItem[index].num > 0)
                {
                    ItemData itemData = new ItemData();
                    itemData.Setup(0L, returnItem[index].iname, (int)returnItem[index].num);
                    itemDataList.Add(itemData);
                }
            }
            return(itemDataList);
        }
        public void Refresh(Dictionary <string, int> dict)
        {
            if (dict == null || dict.Count < 0)
            {
                return;
            }
            GameManager instance = MonoSingleton <GameManager> .Instance;

            using (Dictionary <string, int> .KeyCollection.Enumerator enumerator = dict.Keys.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    string    current   = enumerator.Current;
                    ItemParam itemParam = instance.MasterParam.GetItemParam(current);
                    if (itemParam != null && dict[current] > 0)
                    {
                        ItemData data = new ItemData();
                        data.Setup(0L, itemParam, dict[current]);
                        GameObject gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                        gameObject.get_transform().SetParent((Transform)this.ItemLayoutParent, false);
                        DataSource.Bind <ItemData>(gameObject, data);
                        this.mExpItems.Add(gameObject);
                        gameObject.SetActive(true);
                    }
                }
            }
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 6
0
 private void LoadInventory()
 {
     if (this.mIsUserOwnUnits)
     {
         int index = 0;
         using (Dictionary <OString, OInt> .Enumerator enumerator = SceneBattle.Instance.Battle.GetQuestRecord().used_items.GetEnumerator())
         {
             while (enumerator.MoveNext())
             {
                 KeyValuePair <OString, OInt> current = enumerator.Current;
                 if (index >= this.ItemSlots.Length)
                 {
                     break;
                 }
                 string   key  = (string)current.Key;
                 int      num  = (int)current.Value;
                 ItemData data = new ItemData();
                 data.Setup(0L, key, num);
                 this.ItemSlots[index].SetSlotData <ItemData>(data);
                 ++index;
             }
         }
     }
     else
     {
         if (this.mUsedItems == null)
         {
             return;
         }
         for (int index = 0; index < this.ItemSlots.Length && index < this.mUsedItems.Length; ++index)
         {
             this.ItemSlots[index].SetSlotData <ItemData>(this.mUsedItems[index]);
         }
     }
 }
Ejemplo n.º 7
0
        public static ItemData CreateItemData(ItemParam param, int num = 0)
        {
            ItemData itemData = new ItemData();

            itemData.Setup(0L, param, num);
            return(itemData);
        }
Ejemplo n.º 8
0
        public void Refresh(bool is_quest, PartyWindow2 _party_window)
        {
            PlayerData       player = MonoSingleton <GameManager> .Instance.Player;
            List <ItemParam> list   = MonoSingleton <GameManager> .Instance.MasterParam.Items.Where <ItemParam>((Func <ItemParam, bool>)(x => x.type == EItemType.ApHeal)).ToList <ItemParam>();

            if (list != null)
            {
                for (int index = 0; index < list.Count; ++index)
                {
                    ItemParam iparam = list[index];
                    ItemData  data   = player.Items.Find((Predicate <ItemData>)(x => x.ItemID == iparam.iname));
                    if (data == null)
                    {
                        data = new ItemData();
                        data.Setup(0L, iparam.iname, 0);
                    }
                    GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.mItemBase);
                    ((ListItemEvents)gameObject.GetComponent <ListItemEvents>()).OnSelect = new ListItemEvents.ListItemEvent(this.OnSelect);
                    ((Selectable)gameObject.GetComponent <Button>()).set_interactable(data.Num > 0);
                    DataSource.Bind <ItemData>(gameObject, data);
                    gameObject.get_transform().SetParent(this.mItemParent.get_transform(), false);
                }
            }
            this.mItemBase.SetActive(false);
            if (is_quest && !string.IsNullOrEmpty(GlobalVars.SelectedQuestID))
            {
                this.mQuestParam = MonoSingleton <GameManager> .Instance.FindQuest(GlobalVars.SelectedQuestID);
            }
            this.QuestInfo.SetActive(this.mQuestParam != null);
            this.silder.set_maxValue((float)player.StaminaStockCap);
            this.silder.set_minValue(0.0f);
            this.silder.set_value((float)player.Stamina);
            this.now_ap.set_text(player.Stamina.ToString());
            this.max_ap.set_text(player.StaminaStockCap.ToString());
            if (this.mQuestParam != null)
            {
                int num = this.mQuestParam.RequiredApWithPlayerLv(player.Lv, true);
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)_party_window, (UnityEngine.Object)null) && UnityEngine.Object.op_Inequality((UnityEngine.Object)_party_window.RaidSettings, (UnityEngine.Object)null) && _party_window.MultiRaidNum > 0)
                {
                    num *= _party_window.MultiRaidNum;
                }
                this.LackAp.set_text(LocalizedText.Get("sys.TEXT_APHEAL_LACK_POINT", new object[1]
                {
                    (object)(num - player.Stamina)
                }));
            }
            this.heal_coin_text.set_text(LocalizedText.Get("sys.SKIPBATTLE_HEAL_NUM", new object[1]
            {
                (object)MonoSingleton <GameManager> .Instance.MasterParam.FixParam.StaminaAdd.ToString()
            }));
            this.heal_coin_num.set_text(player.GetStaminaRecoveryCost(false).ToString());
            if (player.StaminaStockCap <= player.Stamina)
            {
                UIUtility.SystemMessage((string)null, LocalizedText.Get("sys.STAMINAFULL"), (UIUtility.DialogResultEvent)(go => FlowNode_GameObject.ActivateOutputLinks((Component)this, 2)), (GameObject)null, false, -1);
            }
            this.pre_ap.set_text(player.Stamina.ToString());
        }
Ejemplo n.º 9
0
        private void Refresh()
        {
            MonoSingleton <GameManager> .Instance.Player.UpdateEventCoin();

            if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.ItemTemplate, (UnityEngine.Object)null))
            {
                return;
            }
            this.SetPossessionCoinParam();
            EventShopData eventShopData = MonoSingleton <GameManager> .Instance.Player.GetEventShopData();

            DebugUtility.Assert(eventShopData != null, "ショップ情報が存在しない");
            for (int index = 0; index < this.mBuyItems.Count; ++index)
            {
                this.mBuyItems[index].get_gameObject().SetActive(false);
            }
            int count = eventShopData.items.Count;

            for (int index = 0; index < count; ++index)
            {
                EventShopItem data1 = eventShopData.items[index];
                if (index >= this.mBuyItems.Count)
                {
                    GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                    gameObject.get_transform().SetParent((Transform)this.ItemLayoutParent, false);
                    this.mBuyItems.Add(gameObject);
                }
                GameObject mBuyItem = this.mBuyItems[index];
                ((EventShopBuyList)mBuyItem.GetComponentInChildren <EventShopBuyList>()).eventShopItem = data1;
                DataSource.Bind <EventShopItem>(mBuyItem, data1);
                if (data1.IsArtifact)
                {
                    ArtifactParam artifactParam = MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(data1.iname);

                    DataSource.Bind <ArtifactParam>(mBuyItem, artifactParam);
                }
                else
                {
                    ItemData data2 = new ItemData();
                    data2.Setup(0L, data1.iname, data1.num);
                    DataSource.Bind <ItemData>(mBuyItem, data2);
                    DataSource.Bind <ItemParam>(mBuyItem, MonoSingleton <GameManager> .Instance.GetItemParam(data1.iname));
                }
                ListItemEvents component1 = (ListItemEvents)mBuyItem.GetComponent <ListItemEvents>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component1, (UnityEngine.Object)null))
                {
                    component1.OnSelect = new ListItemEvents.ListItemEvent(this.OnSelect);
                }
                Button component2 = (Button)mBuyItem.GetComponent <Button>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component2, (UnityEngine.Object)null))
                {
                    ((Selectable)component2).set_interactable(!data1.is_soldout);
                }
                mBuyItem.SetActive(true);
            }
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 10
0
        private RewardData GiftDataToRewardData(GiftData[] giftDatas)
        {
            RewardData rewardData = new RewardData();

            rewardData.Exp        = 0;
            rewardData.Stamina    = 0;
            rewardData.MultiCoin  = 0;
            rewardData.KakeraCoin = 0;
            GameManager instance = MonoSingleton <GameManager> .Instance;

            for (int index = 0; index < giftDatas.Length; ++index)
            {
                GiftData giftData = giftDatas[index];
                rewardData.Coin       += giftData.coin;
                rewardData.Gold       += giftData.gold;
                rewardData.ArenaMedal += giftData.arenacoin;
                rewardData.MultiCoin  += giftData.multicoin;
                rewardData.KakeraCoin += giftData.kakeracoin;
                if (giftData.iname != null)
                {
                    if (giftData.CheckGiftTypeIncluded(GiftTypes.Artifact))
                    {
                        ArtifactParam artifactParam = MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(giftData.iname);

                        if (artifactParam != null)
                        {
                            if (rewardData.GiftRecieveItemDataDic.ContainsKey(giftData.iname))
                            {
                                rewardData.GiftRecieveItemDataDic[giftData.iname].num += giftData.num;
                            }
                            else
                            {
                                GiftRecieveItemData giftRecieveItemData = new GiftRecieveItemData();
                                giftRecieveItemData.Set(giftData.iname, GiftTypes.Artifact, artifactParam.rareini, giftData.num);
                                rewardData.GiftRecieveItemDataDic.Add(giftData.iname, giftRecieveItemData);
                            }
                        }
                    }
                    else
                    {
                        ItemData itemData = new ItemData();
                        if (itemData.Setup(0L, giftData.iname, giftData.num))
                        {
                            rewardData.Items.Add(itemData);
                            ItemData itemDataByItemId = instance.Player.FindItemDataByItemID(itemData.Param.iname);
                            int      num = itemDataByItemId == null ? 0 : itemDataByItemId.Num;
                            rewardData.ItemsBeforeAmount.Add(num);
                        }
                    }
                }
            }
            return(rewardData);
        }
Ejemplo n.º 11
0
        public void Setup(int _index)
        {
            ItemParam itemParam = GachaResultData.drops[_index].item;
            int       num       = GachaResultData.drops[_index].num;

            if (itemParam == null)
            {
                return;
            }
            ItemData _data = new ItemData();

            _data.Setup(0L, itemParam, num);
            this.Setup(_data);
        }
Ejemplo n.º 12
0
        private void Refresh()
        {
            if (Object.op_Equality((Object)this.ItemTemplate, (Object)null))
            {
                return;
            }
            LimitedShopData limitedShopData = MonoSingleton <GameManager> .Instance.Player.GetLimitedShopData();

            DebugUtility.Assert(limitedShopData != null, "Shop information doesn't exist.");
            this.ShopName.set_text(LocalizedText.Get(GlobalVars.LimitedShopItem.shops.info.title));
            for (int index = 0; index < this.mBuyItems.Count; ++index)
            {
                this.mBuyItems[index].get_gameObject().SetActive(false);
            }
            int count = limitedShopData.items.Count;

            for (int index = 0; index < count; ++index)
            {
                LimitedShopItem data1 = limitedShopData.items[index];
                if (index >= this.mBuyItems.Count)
                {
                    GameObject gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                    gameObject.get_transform().SetParent((Transform)this.ItemLayoutParent, false);
                    this.mBuyItems.Add(gameObject);
                }
                GameObject         mBuyItem            = this.mBuyItems[index];
                LimitedShopBuyList componentInChildren = (LimitedShopBuyList)mBuyItem.GetComponentInChildren <LimitedShopBuyList>();
                componentInChildren.limitedShopItem = data1;
                componentInChildren.amount.SetActive(!data1.IsSet);
                DataSource.Bind <LimitedShopItem>(mBuyItem, data1);
                ItemData data2 = new ItemData();
                data2.Setup(0L, data1.iname, data1.num);
                DataSource.Bind <ItemData>(mBuyItem, data2);
                DataSource.Bind <ItemParam>(mBuyItem, MonoSingleton <GameManager> .Instance.GetItemParam(data1.iname));
                ListItemEvents component1 = (ListItemEvents)mBuyItem.GetComponent <ListItemEvents>();
                if (Object.op_Inequality((Object)component1, (Object)null))
                {
                    component1.OnSelect = new ListItemEvents.ListItemEvent(this.OnSelect);
                }
                Button component2 = (Button)mBuyItem.GetComponent <Button>();
                if (Object.op_Inequality((Object)component2, (Object)null))
                {
                    ((Selectable)component2).set_interactable(!data1.is_soldout);
                }
                mBuyItem.SetActive(true);
            }
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 13
0
        private ItemData[] LoadUsedItems(RecentPartyList.JSON_Item[] jsonItem)
        {
            if (jsonItem == null)
            {
                return((ItemData[])null);
            }
            List <ItemData> itemDataList = new List <ItemData>();

            foreach (RecentPartyList.JSON_Item jsonItem1 in jsonItem)
            {
                ItemData itemData = new ItemData();
                itemData.Setup(0L, jsonItem1.iname, jsonItem1.num);
                itemDataList.Add(itemData);
            }
            return(itemDataList.ToArray());
        }
Ejemplo n.º 14
0
        private ItemData[] MergeDropItems(RaidResult raidResult)
        {
            if (raidResult == null)
            {
                return(new ItemData[0]);
            }
            PlayerData      player       = MonoSingleton <GameManager> .Instance.Player;
            List <ItemData> itemDataList = new List <ItemData>();

            using (List <RaidQuestResult> .Enumerator enumerator = raidResult.results.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    RaidQuestResult current = enumerator.Current;
                    if (current != null)
                    {
                        foreach (ItemData drop in current.drops)
                        {
                            if (drop != null)
                            {
                                bool flag = false;
                                for (int index = 0; index < itemDataList.Count; ++index)
                                {
                                    if (itemDataList[index].Param == drop.Param)
                                    {
                                        itemDataList[index].Gain(drop.Num);
                                        flag = true;
                                        break;
                                    }
                                }
                                if (!flag)
                                {
                                    ItemData itemData = new ItemData();
                                    itemData.Setup(drop.UniqueID, drop.Param, drop.Num);
                                    ItemData itemDataByItemParam = player.FindItemDataByItemParam(itemData.Param);
                                    itemData.IsNew = !player.ItemEntryExists(itemData.Param.iname) || (itemDataByItemParam == null || itemDataByItemParam.IsNew);
                                    itemDataList.Add(itemData);
                                }
                            }
                        }
                    }
                }
            }
            return(itemDataList.ToArray());
        }
Ejemplo n.º 15
0
        private GameObject SetItem(string _iname, int _num)
        {
            GameObject gameObject = (GameObject)null;

            if (Object.op_Inequality((Object)this.ItemTemplate, (Object)null))
            {
                gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                if (Object.op_Inequality((Object)gameObject, (Object)null))
                {
                    gameObject.get_transform().SetParent(this.ItemTemplate.get_transform().get_parent(), false);
                    gameObject.SetActive(true);
                    ItemData data = new ItemData();
                    data.Setup(0L, _iname, _num);
                    DataSource.Bind <ItemData>(gameObject, data);
                    this.SetAnimatorTrigger(gameObject, "on");
                }
            }
            return(gameObject);
        }
Ejemplo n.º 16
0
        private void Refresh()
        {
            LimitedShopItem data = MonoSingleton <GameManager> .Instance.Player.GetLimitedShopData().items[GlobalVars.ShopBuyIndex];

            ItemData itemDataByItemId = MonoSingleton <GameManager> .Instance.Player.FindItemDataByItemID(data.iname);

            this.limited_shop_item_set_list.Clear();
            if (data.IsSet)
            {
                for (int index = 0; index < data.children.Length; ++index)
                {
                    GameObject gameObject = index >= this.limited_shop_item_set_list.Count ? (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate) : ((Component)this.limited_shop_item_set_list[index]).get_gameObject();
                    if (Object.op_Inequality((Object)gameObject, (Object)null))
                    {
                        gameObject.SetActive(true);
                        Vector3 localScale = gameObject.get_transform().get_localScale();
                        gameObject.get_transform().SetParent(this.ItemParent.get_transform());
                        gameObject.get_transform().set_localScale(localScale);
                        LimitedShopSetItemListElement component = (LimitedShopSetItemListElement)gameObject.GetComponent <LimitedShopSetItemListElement>();
                        ItemData itemData = new ItemData();
                        itemData.Setup(0L, data.children[index].iname, data.children[index].num);
                        StringBuilder stringBuilder = GameUtility.GetStringBuilder();
                        if (itemData != null)
                        {
                            stringBuilder.Append(itemData.Param.name);
                        }
                        stringBuilder.Append(" × ");
                        stringBuilder.Append(data.children[index].num.ToString());
                        component.itemName.set_text(stringBuilder.ToString());
                        component.itemData = itemData;
                        this.limited_shop_item_set_list.Add(component);
                    }
                }
            }
            DataSource.Bind <LimitedShopItem>(((Component)this).get_gameObject(), data);
            DataSource.Bind <ItemData>(((Component)this).get_gameObject(), itemDataByItemId);
            DataSource.Bind <ItemParam>(((Component)this).get_gameObject(), MonoSingleton <GameManager> .Instance.GetItemParam(data.iname));
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 17
0
        public RewardData(TrophyParam trophy)
        {
            this.Exp     = trophy.Exp;
            this.Coin    = trophy.Coin;
            this.Gold    = trophy.Gold;
            this.Stamina = trophy.Stamina;
            GameManager instance = MonoSingleton <GameManager> .Instance;

            foreach (TrophyParam.RewardItem rewardItem in trophy.Items)
            {
                ItemData itemData = new ItemData();
                if (itemData.Setup(0L, rewardItem.iname, rewardItem.Num))
                {
                    this.Items.Add(itemData);
                    if (itemData.Param.type != EItemType.Unit)
                    {
                        ItemData itemDataByItemId = instance.Player.FindItemDataByItemID(itemData.Param.iname);
                        this.ItemsBeforeAmount.Add(itemDataByItemId == null ? 0 : itemDataByItemId.Num);
                    }
                    else
                    {
                        this.ItemsBeforeAmount.Add(instance.Player.Units.Find((Predicate <UnitData>)(u => u.UnitParam.iname == itemData.ItemID)) == null ? 0 : 1);
                    }
                }
            }
            foreach (TrophyParam.RewardItem artifact in trophy.Artifacts)
            {
                this.Artifacts.Add(new ArtifactRewardData()
                {
                    ArtifactParam = instance.MasterParam.GetArtifactParam(artifact.iname),
                    Num           = artifact.Num
                });
            }
            foreach (TrophyParam.RewardItem conceptCard in trophy.ConceptCards)
            {
                this.AddReward(instance.MasterParam.GetConceptCardParam(conceptCard.iname), conceptCard.Num);
            }
        }
Ejemplo n.º 18
0
        private void Refresh()
        {
            GameUtility.DestroyGameObjects(this.mItems);
            this.mItems.Clear();
            LimitedShopData limitedShopData = MonoSingleton <GameManager> .Instance.Player.GetLimitedShopData();

            if (limitedShopData == null || limitedShopData.items.Count <= 0)
            {
                return;
            }
            int shopBuyIndex = GlobalVars.ShopBuyIndex;

            if (!Object.op_Inequality((Object)this.ItemTemplate, (Object)null))
            {
                return;
            }
            Transform       transform       = !Object.op_Inequality((Object)this.ItemParent, (Object)null) ? this.ItemTemplate.get_transform().get_parent() : this.ItemParent.get_transform();
            LimitedShopItem limitedShopItem = limitedShopData.items[shopBuyIndex];

            if (limitedShopItem.children != null && limitedShopItem.children.Length > 0)
            {
                foreach (Json_ShopItemDesc child in limitedShopItem.children)
                {
                    ItemData data = new ItemData();
                    data.Setup(0L, child.iname, child.num);
                    if (data != null)
                    {
                        GameObject gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                        gameObject.get_transform().SetParent(transform, false);
                        DataSource.Bind <ItemData>(gameObject, data);
                        this.mItems.Add(gameObject);
                        gameObject.SetActive(true);
                    }
                }
            }
            GameParameter.UpdateAll(((Component)transform).get_gameObject());
        }
Ejemplo n.º 19
0
        private void MiscBeforeDefaultState()
        {
            this.NotifyNewFriendRequests();
            if (HomeWindow.EnterHomeCount == 0)
            {
                this.CheckTrophies();
            }
            if (this.mNewsShown || GlobalVars.IsTitleStart.Get() || !MonoSingleton <GameManager> .Instance.Player.IsFirstLogin && !this.DebugLoginBonus)
            {
                return;
            }
            this.mNewsShown = true;
            Json_LoginBonus recentLoginBonus = MonoSingleton <GameManager> .Instance.Player.RecentLoginBonus;

            if (recentLoginBonus != null)
            {
                string iname;
                int    num;
                if (recentLoginBonus.coin > 0)
                {
                    iname = "$COIN";
                    num   = recentLoginBonus.coin;
                }
                else
                {
                    iname = recentLoginBonus.iname;
                    num   = recentLoginBonus.num;
                }
                ItemData data = new ItemData();
                if (data.Setup(0L, iname, num))
                {
                    NotifyList.PushLoginBonus(data);
                }
            }
            this.NotifySupportResult();
        }
Ejemplo n.º 20
0
        public void Refresh(UnitData unit = null, JobParam jobUnlock = null)
        {
            if (unit == null)
            {
                return;
            }
            this.mCurrentUnit    = unit;
            this.mUnlockJobParam = jobUnlock;
            this.mUsedElemPieces.Clear();
            this.mCacheCCJobs.Clear();
            this.mTempUnit = new UnitData();
            this.mTempUnit.Setup(unit);
            for (int index = 0; index < this.mUnlockJobList.Count; ++index)
            {
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.mUnlockJobList[index], (UnityEngine.Object)null))
                {
                    DataSource.Bind <JobParam>(this.mUnlockJobList[index], (JobParam)null);
                    this.mUnlockJobList[index].SetActive(false);
                }
            }
            int length = unit.Jobs.Length;

            if (this.mUnlockJobList.Count < length)
            {
                int num = length - this.mUnlockJobList.Count;
                for (int index = 0; index < num; ++index)
                {
                    GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.JobUnlock);
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)gameObject, (UnityEngine.Object)null))
                    {
                        gameObject.get_transform().SetParent((Transform)this.JobUnlockParent, false);
                        this.mUnlockJobList.Add(gameObject);
                    }
                }
            }
            JobSetParam[] changeJobSetParam = MonoSingleton <GameManager> .Instance.MasterParam.GetClassChangeJobSetParam(unit.UnitParam.iname);

            if (changeJobSetParam != null)
            {
                this.mCacheCCJobs.AddRange((IEnumerable <JobSetParam>)changeJobSetParam);
            }
            for (int jobNo = 0; jobNo < length; ++jobNo)
            {
                if (!unit.CheckJobUnlockable(jobNo) && UnityEngine.Object.op_Inequality((UnityEngine.Object) this.mUnlockJobList[jobNo], (UnityEngine.Object)null))
                {
                    DataSource.Bind <JobParam>(this.mUnlockJobList[jobNo], unit.Jobs[jobNo].Param);
                }
            }
            DataSource.Bind <UnitData>(((Component)this).get_gameObject(), (UnitData)null);
            GameParameter.UpdateAll(((Component)this).get_gameObject());
            DataSource.Bind <UnitData>(((Component)this).get_gameObject(), this.mTempUnit);
            int  awakeLv = unit.AwakeLv;
            bool flag1   = unit.GetAwakeLevelCap() > awakeLv;

            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.CautionObject, (UnityEngine.Object)null))
            {
                this.CautionObject.SetActive(!flag1);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.DecideButton, (UnityEngine.Object)null))
            {
                ((Selectable)this.DecideButton).set_interactable(flag1 && unit.CheckUnitAwaking());
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null))
            {
                ((Selectable)this.SelectAwakeSlider).set_interactable(flag1 && unit.CheckUnitAwaking());
            }
            if (flag1)
            {
                PlayerData player          = MonoSingleton <GameManager> .Instance.Player;
                int        awakeNeedPieces = unit.GetAwakeNeedPieces();
                bool       flag2           = false;
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Unit, (UnityEngine.Object)null))
                {
                    ItemData data = player.FindItemDataByItemID(unit.UnitParam.piece);
                    if (data == null)
                    {
                        ItemParam itemParam = MonoSingleton <GameManager> .Instance.MasterParam.GetItemParam(unit.UnitParam.piece);

                        if (itemParam == null)
                        {
                            DebugUtility.LogError("Not Unit Piece Settings => [" + unit.UnitParam.iname + "]");
                            return;
                        }
                        data = new ItemData();
                        data.Setup(0L, itemParam, 0);
                    }
                    if (data != null)
                    {
                        DataSource.Bind <ItemData>(this.Kakera_Unit, data);
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Amount_Unit, (UnityEngine.Object)null))
                    {
                        this.Kakera_Amount_Unit.set_text(data.Num.ToString());
                    }
                    int num = Math.Min(awakeNeedPieces, data.Num);
                    if (awakeNeedPieces > 0)
                    {
                        num              = Math.Min(awakeNeedPieces, data.Num);
                        flag2            = true;
                        awakeNeedPieces -= num;
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Unit, (UnityEngine.Object)null))
                    {
                        this.Kakera_Consume_Unit.set_text("@" + num.ToString());
                    }
                    this.Kakera_Unit.SetActive(true);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Elem, (UnityEngine.Object)null))
                {
                    ItemData data = unit.GetElementPieceData();
                    if (data == null)
                    {
                        ItemParam elementPieceParam = unit.GetElementPieceParam();
                        if (elementPieceParam == null)
                        {
                            DebugUtility.LogError("[Unit Setting Error?]Not Element Piece!");
                            return;
                        }
                        data = new ItemData();
                        data.Setup(0L, elementPieceParam, 0);
                    }
                    if (data != null)
                    {
                        DataSource.Bind <ItemData>(this.Kakera_Elem, data);
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Amount_Elem, (UnityEngine.Object)null))
                    {
                        this.Kakera_Amount_Elem.set_text(data.Num.ToString());
                    }
                    int num = Math.Min(awakeNeedPieces, data.Num);
                    if (data.Num > 0 && awakeNeedPieces > 0)
                    {
                        num              = Math.Min(awakeNeedPieces, data.Num);
                        flag2            = true;
                        awakeNeedPieces -= num;
                        if (!this.mUsedElemPieces.Contains(data))
                        {
                            this.mUsedElemPieces.Add(data);
                        }
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Elem, (UnityEngine.Object)null))
                    {
                        this.Kakera_Consume_Elem.set_text("@" + num.ToString());
                    }
                    this.Kakera_Elem.SetActive(true);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Common, (UnityEngine.Object)null))
                {
                    ItemData data = unit.GetCommonPieceData();
                    if (data == null)
                    {
                        ItemParam commonPieceParam = unit.GetCommonPieceParam();
                        if (commonPieceParam == null)
                        {
                            DebugUtility.LogError("[FixParam Setting Error?]Not Common Piece Settings!");
                            return;
                        }
                        data = new ItemData();
                        data.Setup(0L, commonPieceParam, 0);
                    }
                    if (data != null)
                    {
                        DataSource.Bind <ItemData>(this.Kakera_Common, data);
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Amount_Common, (UnityEngine.Object)null))
                    {
                        this.Kakera_Amount_Common.set_text(data.Num.ToString());
                    }
                    int num = 0;
                    if (data.Num > 0 && awakeNeedPieces > 0)
                    {
                        num              = Math.Min(awakeNeedPieces, data.Num);
                        flag2            = true;
                        awakeNeedPieces -= num;
                        if (!this.mUsedElemPieces.Contains(data))
                        {
                            this.mUsedElemPieces.Add(data);
                        }
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Common, (UnityEngine.Object)null))
                    {
                        this.Kakera_Consume_Common.set_text("@" + num.ToString());
                    }
                    this.Kakera_Common.SetActive(true);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null))
                {
                    ItemData itemDataByItemId     = player.FindItemDataByItemID(unit.UnitParam.piece);
                    int      piece_amount         = itemDataByItemId == null ? 0 : itemDataByItemId.Num;
                    ItemData elementPieceData     = unit.GetElementPieceData();
                    int      element_piece_amount = elementPieceData == null ? 0 : elementPieceData.Num;
                    ItemData commonPieceData      = unit.GetCommonPieceData();
                    int      common_piece_amount  = commonPieceData == null ? 0 : commonPieceData.Num;
                    int      num = this.CalcCanAwakeMaxLv(unit.AwakeLv, unit.GetAwakeLevelCap(), piece_amount, element_piece_amount, common_piece_amount);
                    ((UnityEventBase)this.SelectAwakeSlider.get_onValueChanged()).RemoveAllListeners();
                    this.SelectAwakeSlider.set_minValue(num - unit.AwakeLv <= 0 ? 0.0f : 1f);
                    this.SelectAwakeSlider.set_maxValue((float)(num - unit.AwakeLv));
                    this.SelectAwakeSlider.set_value(this.SelectAwakeSlider.get_minValue());
                    // ISSUE: method pointer
                    ((UnityEvent <float>) this.SelectAwakeSlider.get_onValueChanged()).AddListener(new UnityAction <float>((object)this, __methodptr(OnAwakeLvSelect)));
                }
                if (this.mUnlockJobList != null)
                {
                    for (int index = 0; index < this.mUnlockJobList.Count && index <= length; ++index)
                    {
                        if (this.mCacheCCJobs != null && this.mCacheCCJobs.Count > 0)
                        {
                            JobSetParam js = unit.GetJobSetParam(index);
                            if (js == null || this.mCacheCCJobs.Find((Predicate <JobSetParam>)(v => v.iname == js.iname)) != null)
                            {
                                continue;
                            }
                        }
                        this.mUnlockJobList[index].SetActive(this.CheckUnlockJob(index, awakeLv + (int)this.SelectAwakeSlider.get_value()));
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.AwakeResultLv, (UnityEngine.Object)null))
                {
                    this.AwakeResultLv.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_LV", new object[1]
                    {
                        (object)(!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) ? 1 : (int)this.SelectAwakeSlider.get_value())
                    }));
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.AwakeResultComb, (UnityEngine.Object)null))
                {
                    this.AwakeResultComb.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_COMB", new object[1]
                    {
                        (object)(!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) ? 1 : (int)this.SelectAwakeSlider.get_value())
                    }));
                }
                int    num1 = 0;
                OInt[] artifactSlotUnlock = MonoSingleton <GameManager> .GetInstanceDirect().MasterParam.FixParam.EquipArtifactSlotUnlock;

                for (int index = 0; index < artifactSlotUnlock.Length; ++index)
                {
                    if ((int)artifactSlotUnlock[index] != 0 && (int)artifactSlotUnlock[index] > unit.AwakeLv && (int)artifactSlotUnlock[index] <= unit.AwakeLv + (int)this.SelectAwakeSlider.get_value())
                    {
                        ++num1;
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.UnlockArtifactSlot, (UnityEngine.Object)null))
                {
                    this.UnlockArtifactSlot.SetActive(num1 > 0);
                    if (num1 > 0)
                    {
                        this.AwakeResultArtifactSlots.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_SLOT", new object[1]
                        {
                            (object)num1
                        }));
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.NotPieceDataMask, (UnityEngine.Object)null))
                {
                    this.NotPieceDataMask.SetActive(awakeNeedPieces > 0);
                }
                if (flag2)
                {
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Message, (UnityEngine.Object)null))
                    {
                        this.Kakera_Consume_Message.set_text(LocalizedText.Get(awakeNeedPieces != 0 ? "sys.CONFIRM_KAKUSEI4" : "sys.CONFIRM_KAKUSEI2"));
                    }
                }
                else
                {
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Caution_Message, (UnityEngine.Object)null))
                    {
                        this.Kakera_Caution_Message.set_text(LocalizedText.Get("sys.CONFIRM_KAKUSEI3"));
                    }
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.CautionObject, (UnityEngine.Object)null))
                    {
                        this.CautionObject.SetActive(true);
                    }
                }
            }
            else if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Caution_Message, (UnityEngine.Object)null))
            {
                this.Kakera_Caution_Message.set_text(LocalizedText.Get("sys.KAKUSEI_CAPPED"));
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.PlusBtn, (UnityEngine.Object)null))
            {
                ((Selectable)this.PlusBtn).set_interactable(UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) && (double)this.SelectAwakeSlider.get_value() < (double)this.SelectAwakeSlider.get_maxValue());
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.MinusBtn, (UnityEngine.Object)null))
            {
                ((Selectable)this.MinusBtn).set_interactable(UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) && (double)this.SelectAwakeSlider.get_value() > (double)this.SelectAwakeSlider.get_minValue());
            }
            this.RefreshGainedQuests(unit);
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 21
0
        private void Refresh()
        {
            if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.ItemTemplate, (UnityEngine.Object)null))
            {
                return;
            }
            LimitedShopData limitedShopData = MonoSingleton <GameManager> .Instance.Player.GetLimitedShopData();

            DebugUtility.Assert(limitedShopData != null, "ショップ情報が存在しない");
            this.ShopName.set_text(GlobalVars.LimitedShopItem.shops.info.title);
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Updated, (UnityEngine.Object)null))
            {
                this.Updated.SetActive(GlobalVars.LimitedShopItem.btn_update);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Update, (UnityEngine.Object)null))
            {
                this.Update.SetActive(GlobalVars.LimitedShopItem.btn_update);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Lineup, (UnityEngine.Object)null))
            {
                this.Lineup.SetActive(GlobalVars.LimitedShopItem.btn_update);
            }
            for (int index = 0; index < this.mBuyItems.Count; ++index)
            {
                this.mBuyItems[index].get_gameObject().SetActive(false);
            }
            int      count      = limitedShopData.items.Count;
            DateTime serverTime = TimeManager.ServerTime;
            List <LimitedShopItem> nearbyTimeout = new List <LimitedShopItem>();

            for (int index = 0; index < count; ++index)
            {
                LimitedShopItem data1 = limitedShopData.items[index];
                if (data1.end != 0L)
                {
                    DateTime dateTime = TimeManager.FromUnixTime(data1.end);
                    if (!(serverTime >= dateTime))
                    {
                        if ((dateTime - serverTime).TotalHours < 1.0)
                        {
                            nearbyTimeout.Add(data1);
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                if (index >= this.mBuyItems.Count)
                {
                    GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.ItemTemplate);
                    gameObject.get_transform().SetParent((Transform)this.ItemLayoutParent, false);
                    this.mBuyItems.Add(gameObject);
                }
                GameObject         mBuyItem            = this.mBuyItems[index];
                LimitedShopBuyList componentInChildren = (LimitedShopBuyList)mBuyItem.GetComponentInChildren <LimitedShopBuyList>();
                componentInChildren.limitedShopItem = data1;
                DataSource.Bind <LimitedShopItem>(mBuyItem, data1);
                componentInChildren.amount.SetActive(!data1.IsSet);
                if (data1.IsArtifact)
                {
                    ArtifactParam artifactParam = MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(data1.iname);

                    DataSource.Bind <ArtifactParam>(mBuyItem, artifactParam);
                }
                else if (data1.IsConceptCard)
                {
                    ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(data1.iname);
                    componentInChildren.SetupConceptCard(cardDataForDisplay);
                }
                else if (data1.IsItem || data1.IsSet)
                {
                    ItemData data2 = new ItemData();
                    data2.Setup(0L, data1.iname, data1.num);
                    DataSource.Bind <ItemData>(mBuyItem, data2);
                    DataSource.Bind <ItemParam>(mBuyItem, MonoSingleton <GameManager> .Instance.GetItemParam(data1.iname));
                }
                else
                {
                    DebugUtility.LogError(string.Format("不明な商品タイプが設定されています (shopitem.iname({0}) => {1})", (object)data1.iname, (object)data1.ShopItemType));
                }
                ListItemEvents component1 = (ListItemEvents)mBuyItem.GetComponent <ListItemEvents>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component1, (UnityEngine.Object)null))
                {
                    component1.OnSelect = new ListItemEvents.ListItemEvent(this.OnSelect);
                }
                Button component2 = (Button)mBuyItem.GetComponent <Button>();
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component2, (UnityEngine.Object)null))
                {
                    ((Selectable)component2).set_interactable(!data1.is_soldout);
                }
                mBuyItem.SetActive(true);
            }
            this.ShowAndSaveTimeOutItem(nearbyTimeout);
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 22
0
        public void ReceiveReward(VersusRankMissionParam mission)
        {
            GameManager gm = MonoSingleton <GameManager> .Instance;

            gm.Player.RewardedRankMatchMission(mission.IName);
            RewardData param = new RewardData();

            gm.GetVersusRankClassRewardList(mission.RewardId).ForEach((Action <VersusRankReward>)(reward =>
            {
                switch (reward.Type)
                {
                case RewardType.Item:
                    ItemParam itemParam = gm.GetItemParam(reward.IName);
                    if (itemParam == null)
                    {
                        break;
                    }
                    ItemData itemData = new ItemData();
                    if (!itemData.Setup(0L, itemParam.iname, reward.Num))
                    {
                        break;
                    }
                    param.Items.Add(itemData);
                    break;

                case RewardType.Gold:
                    param.Gold = reward.Num;
                    break;

                case RewardType.Coin:
                    param.Coin = reward.Num;
                    break;

                case RewardType.Artifact:
                    ArtifactParam artifactParam = gm.MasterParam.GetArtifactParam(reward.IName);
                    if (artifactParam == null)
                    {
                        break;
                    }
                    param.Artifacts.Add(new ArtifactRewardData()
                    {
                        ArtifactParam = artifactParam,
                        Num           = 1
                    });
                    break;

                case RewardType.Unit:
                    if (gm.GetUnitParam(reward.IName) == null)
                    {
                        break;
                    }
                    param.GiftRecieveItemDataDic.Add(reward.IName, new GiftRecieveItemData()
                    {
                        iname = reward.IName,
                        num   = 1,
                        type  = GiftTypes.Unit
                    });
                    break;
                }
            }));
            GlobalVars.LastReward.Set(param);
            this.mAPIType = RankMatchMissionWindow.APIType.MISSION_EXEC;
            Network.RequestAPI((WebAPI) new ReqRankMatchMissionExec(mission.IName, new Network.ResponseCallback(this.ResponseCallback)), false);
        }
Ejemplo n.º 23
0
        public void PointRefresh()
        {
            this.mUsedElemPieces.Clear();
            PlayerData player = MonoSingleton <GameManager> .GetInstanceDirect().Player;

            UnitData unitData = new UnitData();

            unitData.Setup(this.mCurrentUnit);
            int awake_lv = unitData.AwakeLv + (int)this.SelectAwakeSlider.get_value();
            int val1     = this.CalcNeedPieceAll((int)this.SelectAwakeSlider.get_value());

            this.mTempUnit.SetVirtualAwakeLv(Mathf.Min(unitData.GetAwakeLevelCap(), awake_lv - 1));
            int num1 = 0;

            OInt[] artifactSlotUnlock = MonoSingleton <GameManager> .GetInstanceDirect().MasterParam.FixParam.EquipArtifactSlotUnlock;

            for (int index = 0; index < artifactSlotUnlock.Length; ++index)
            {
                if ((int)artifactSlotUnlock[index] != 0 && (int)artifactSlotUnlock[index] > unitData.AwakeLv && (int)artifactSlotUnlock[index] <= unitData.AwakeLv + (int)this.SelectAwakeSlider.get_value())
                {
                    ++num1;
                }
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Unit, (UnityEngine.Object)null))
            {
                ItemData itemData = player.FindItemDataByItemID(unitData.UnitParam.piece);
                if (itemData == null)
                {
                    ItemParam itemParam = MonoSingleton <GameManager> .Instance.MasterParam.GetItemParam(unitData.UnitParam.piece);

                    if (itemParam == null)
                    {
                        DebugUtility.LogError("Not Unit Piece Settings => [" + unitData.UnitParam.iname + "]");
                        return;
                    }
                    itemData = new ItemData();
                    itemData.Setup(0L, itemParam, 0);
                }
                int num2 = Math.Min(val1, itemData.Num);
                if (val1 > 0)
                {
                    num2  = Math.Min(val1, itemData.Num);
                    val1 -= num2;
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Unit, (UnityEngine.Object)null))
                {
                    this.Kakera_Consume_Unit.set_text("@" + num2.ToString());
                }
                this.Kakera_Unit.SetActive(true);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Elem, (UnityEngine.Object)null) && UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Elem, (UnityEngine.Object)null))
            {
                ItemData data = unitData.GetElementPieceData();
                if (data == null)
                {
                    ItemParam elementPieceParam = unitData.GetElementPieceParam();
                    if (elementPieceParam == null)
                    {
                        DebugUtility.LogError("[Unit Setting Error?]Not Element Piece!");
                        return;
                    }
                    data = new ItemData();
                    data.Setup(0L, elementPieceParam, 0);
                }
                if (data != null)
                {
                    DataSource.Bind <ItemData>(this.Kakera_Elem, data);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Amount_Elem, (UnityEngine.Object)null))
                {
                    this.Kakera_Amount_Elem.set_text(data.Num.ToString());
                }
                int num2 = 0;
                if (data.Num > 0 && val1 > 0)
                {
                    num2  = Math.Min(val1, data.Num);
                    val1 -= num2;
                    if (!this.mUsedElemPieces.Contains(data))
                    {
                        this.mUsedElemPieces.Add(data);
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Elem, (UnityEngine.Object)null))
                {
                    this.Kakera_Consume_Elem.set_text("@" + num2.ToString());
                }
                this.Kakera_Elem.SetActive(true);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Common, (UnityEngine.Object)null))
            {
                ItemData data = unitData.GetCommonPieceData();
                if (data == null)
                {
                    ItemParam commonPieceParam = unitData.GetCommonPieceParam();
                    if (commonPieceParam == null)
                    {
                        DebugUtility.LogError("[FixParam Setting Error?]Not Common Piece Settings!");
                        return;
                    }
                    data = new ItemData();
                    data.Setup(0L, commonPieceParam, 0);
                }
                if (data != null)
                {
                    DataSource.Bind <ItemData>(this.Kakera_Common, data);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Amount_Common, (UnityEngine.Object)null))
                {
                    this.Kakera_Amount_Common.set_text(data.Num.ToString());
                }
                int num2 = 0;
                if (data.Num > 0 && val1 > 0)
                {
                    num2 = Math.Min(val1, data.Num);
                    int num3 = val1 - num2;
                    if (!this.mUsedElemPieces.Contains(data))
                    {
                        this.mUsedElemPieces.Add(data);
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Kakera_Consume_Common, (UnityEngine.Object)null))
                {
                    this.Kakera_Consume_Common.set_text("@" + num2.ToString());
                }
                this.Kakera_Common.SetActive(true);
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.AwakeResultLv, (UnityEngine.Object)null))
            {
                this.AwakeResultLv.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_LV", new object[1]
                {
                    (object)(!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) ? 1 : (int)this.SelectAwakeSlider.get_value())
                }));
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.AwakeResultComb, (UnityEngine.Object)null))
            {
                this.AwakeResultComb.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_COMB", new object[1]
                {
                    (object)(!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) ? 1 : (int)this.SelectAwakeSlider.get_value())
                }));
            }
            if (this.mUnlockJobList != null)
            {
                for (int index = 0; index < this.mUnlockJobList.Count && index <= unitData.Jobs.Length; ++index)
                {
                    if (this.mCacheCCJobs != null && this.mCacheCCJobs.Count > 0)
                    {
                        JobSetParam js = unitData.GetJobSetParam(index);
                        if (js == null || this.mCacheCCJobs.Find((Predicate <JobSetParam>)(v => v.iname == js.iname)) != null)
                        {
                            continue;
                        }
                    }
                    this.mUnlockJobList[index].SetActive(this.CheckUnlockJob(index, awake_lv));
                }
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.UnlockArtifactSlot, (UnityEngine.Object)null))
            {
                this.UnlockArtifactSlot.SetActive(num1 > 0);
                if (num1 > 0 && UnityEngine.Object.op_Inequality((UnityEngine.Object) this.AwakeResultArtifactSlots, (UnityEngine.Object)null))
                {
                    this.AwakeResultArtifactSlots.set_text(LocalizedText.Get("sys.TEXT_UNITAWAKE_RESULT_SLOT", new object[1]
                    {
                        (object)num1
                    }));
                }
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.PlusBtn, (UnityEngine.Object)null))
            {
                ((Selectable)this.PlusBtn).set_interactable(UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) && (double)this.SelectAwakeSlider.get_value() < (double)this.SelectAwakeSlider.get_maxValue());
            }
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.MinusBtn, (UnityEngine.Object)null))
            {
                ((Selectable)this.MinusBtn).set_interactable(UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SelectAwakeSlider, (UnityEngine.Object)null) && (double)this.SelectAwakeSlider.get_value() > (double)this.SelectAwakeSlider.get_minValue());
            }
            GameParameter.UpdateAll(((Component)this).get_gameObject());
        }
Ejemplo n.º 24
0
        private void Refresh()
        {
            GameUtility.DestroyGameObjects(this.mItems);
            this.mItems.Clear();
            ShopData shopData = MonoSingleton <GameManager> .Instance.Player.GetShopData(GlobalVars.ShopType);

            if (shopData == null || shopData.items.Count <= 0 || UnityEngine.Object.op_Equality((UnityEngine.Object) this.ItemTemplate, (UnityEngine.Object)null))
            {
                return;
            }
            int       shopdata_index = GlobalVars.ShopBuyIndex;
            Transform parent         = !UnityEngine.Object.op_Inequality((UnityEngine.Object) this.ItemParent, (UnityEngine.Object)null) ? this.ItemTemplate.get_transform().get_parent() : this.ItemParent.get_transform();
            ShopItem  shopItem       = shopData.items.FirstOrDefault <ShopItem>((Func <ShopItem, bool>)(item => item.id == shopdata_index));
            List <Json_ShopItemDesc> jsonShopItemDescList = new List <Json_ShopItemDesc>();

            if (shopItem.IsArtifact)
            {
                jsonShopItemDescList.Add(new Json_ShopItemDesc()
                {
                    iname = shopItem.iname,
                    itype = ShopData.ShopItemType2String(shopItem.ShopItemType),
                    num   = shopItem.num
                });
            }
            else if (shopItem.children != null && shopItem.children.Length > 0)
            {
                jsonShopItemDescList.AddRange((IEnumerable <Json_ShopItemDesc>)shopItem.children);
            }
            if (jsonShopItemDescList.Count > 0)
            {
                for (int index = 0; index < jsonShopItemDescList.Count; ++index)
                {
                    Json_ShopItemDesc shop_item_desc = jsonShopItemDescList[index];
                    string            empty          = string.Empty;
                    GameObject        gameObject;
                    string            name;
                    if (shop_item_desc.IsArtifact)
                    {
                        ArtifactParam artifactParam = MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(shop_item_desc.iname);

                        if (artifactParam != null)
                        {
                            gameObject = this.InstantiateItem <ArtifactParam>(this.ItemTemplate, parent, artifactParam);
                            name       = artifactParam.name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    else if (shop_item_desc.IsConceptCard)
                    {
                        ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(shop_item_desc.iname);
                        if (cardDataForDisplay != null)
                        {
                            gameObject = this.InstantiateItem <ConceptCardData>(this.ItemTemplate, parent, cardDataForDisplay);
                            ConceptCardIcon componentInChildren = (ConceptCardIcon)gameObject.GetComponentInChildren <ConceptCardIcon>();
                            if (UnityEngine.Object.op_Inequality((UnityEngine.Object)componentInChildren, (UnityEngine.Object)null))
                            {
                                componentInChildren.Setup(cardDataForDisplay);
                            }
                            name = cardDataForDisplay.Param.name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    else
                    {
                        ItemData itemData = new ItemData();
                        if (itemData.Setup(0L, shop_item_desc.iname, shop_item_desc.num))
                        {
                            gameObject = this.InstantiateItem <ItemData>(this.ItemTemplate, parent, itemData);
                            name       = itemData.Param.name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    ShopGiftItem component = (ShopGiftItem)gameObject.GetComponent <ShopGiftItem>();
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component, (UnityEngine.Object)null))
                    {
                        component.SetShopItemInfo(shop_item_desc, name, GlobalVars.ShopBuyAmount);
                    }
                }
            }
            GameParameter.UpdateAll(((Component)parent).get_gameObject());
        }
Ejemplo n.º 25
0
        private void Refresh()
        {
            GameUtility.DestroyGameObjects(this.mItems);
            this.mItems.Clear();
            EventShopData eventShopData = MonoSingleton <GameManager> .Instance.Player.GetEventShopData();

            if (eventShopData == null || eventShopData.items.Count <= 0 || Object.op_Equality((Object)this.ItemTemplate, (Object)null))
            {
                return;
            }
            int           shopBuyIndex  = GlobalVars.ShopBuyIndex;
            Transform     parent        = !Object.op_Inequality((Object)this.ItemParent, (Object)null) ? this.ItemTemplate.get_transform().get_parent() : this.ItemParent.get_transform();
            EventShopItem eventShopItem = eventShopData.items[shopBuyIndex];

            if (eventShopItem.IsArtifact)
            {
                eventShopItem.children          = new Json_ShopItemDesc[1];
                eventShopItem.children[0]       = new Json_ShopItemDesc();
                eventShopItem.children[0].iname = eventShopItem.iname;
                eventShopItem.children[0].num   = eventShopItem.num;
            }
            if (eventShopItem.children != null && eventShopItem.children.Length > 0)
            {
                foreach (Json_ShopItemDesc child in eventShopItem.children)
                {
                    string     empty = string.Empty;
                    GameObject gameObject;
                    string     name;
                    if (child.IsArtifact)
                    {
                        ArtifactParam artifactParam = MonoSingleton <GameManager> .Instance.MasterParam.GetArtifactParam(child.iname);

                        if (artifactParam != null)
                        {
                            gameObject = this.InstantiateItem <ArtifactParam>(this.ItemTemplate, parent, artifactParam);
                            name       = artifactParam.name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    else
                    {
                        ItemData itemData = new ItemData();
                        if (itemData.Setup(0L, child.iname, child.num))
                        {
                            gameObject = this.InstantiateItem <ItemData>(this.ItemTemplate, parent, itemData);
                            name       = itemData.Param.name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    EventShopGiftItem component = (EventShopGiftItem)gameObject.GetComponent <EventShopGiftItem>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        component.SetShopItemInfo(child, name);
                    }
                }
            }
            GameParameter.UpdateAll(((Component)parent).get_gameObject());
        }
Ejemplo n.º 26
0
        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);
        }
Ejemplo n.º 27
0
        private void OnAllReadAccept()
        {
            if (this.mUnreadMails.Count < 1)
            {
                return;
            }
            this.RefreshCurrentNums();
            RewardData rewardData1 = new RewardData();
            List <MailList.ItemListEntity> itemListEntityList = new List <MailList.ItemListEntity>();
            int num1 = 0;

            for (int index1 = 0; index1 < this.mUnreadMails.Count && num1 < this.MaxReadCount; ++index1)
            {
                MailData dataOfClass = DataSource.FindDataOfClass <MailData>(this.mUnreadMails[index1], (MailData)null);
                if (dataOfClass != null)
                {
                    RewardData rewardData2 = this.GiftDataToRewardData(dataOfClass.gifts);
                    if (this.CheckRecievable(rewardData2))
                    {
                        ++num1;
                        using (Dictionary <string, GiftRecieveItemData> .ValueCollection.Enumerator enumerator = rewardData2.GiftRecieveItemDataDic.Values.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                GiftRecieveItemData current = enumerator.Current;
                                if (rewardData1.GiftRecieveItemDataDic.ContainsKey(current.iname))
                                {
                                    rewardData1.GiftRecieveItemDataDic[current.iname].num += current.num;
                                }
                                else
                                {
                                    rewardData1.GiftRecieveItemDataDic.Add(current.iname, current);
                                }
                                this.AddCurrentNum(current);
                            }
                        }
                        rewardData1.Exp        += rewardData2.Exp;
                        rewardData1.Stamina    += rewardData2.Stamina;
                        rewardData1.Coin       += rewardData2.Coin;
                        rewardData1.Gold       += rewardData2.Gold;
                        rewardData1.ArenaMedal += rewardData2.ArenaMedal;
                        rewardData1.MultiCoin  += rewardData2.MultiCoin;
                        rewardData1.KakeraCoin += rewardData2.KakeraCoin;
                        for (int index2 = 0; index2 < rewardData2.Items.Count; ++index2)
                        {
                            ItemData itemData = rewardData2.Items[index2];
                            if (itemListEntityList.Count > 0)
                            {
                                bool flag = false;
                                for (int index3 = 0; index3 < itemListEntityList.Count; ++index3)
                                {
                                    if (itemListEntityList[index3].Item.ItemID == itemData.ItemID)
                                    {
                                        itemListEntityList[index3].Num += itemData.Num;
                                        flag = true;
                                        break;
                                    }
                                }
                                if (!flag)
                                {
                                    itemListEntityList.Add(new MailList.ItemListEntity(itemData.Num, itemData));
                                }
                            }
                            else
                            {
                                itemListEntityList.Add(new MailList.ItemListEntity(itemData.Num, itemData));
                            }
                        }
                    }
                }
            }
            GameManager instance = MonoSingleton <GameManager> .Instance;

            for (int index = 0; index < itemListEntityList.Count; ++index)
            {
                MailList.ItemListEntity itemListEntity = itemListEntityList[index];
                ItemData itemDataByItemId = instance.Player.FindItemDataByItemID(itemListEntity.Item.Param.iname);
                int      num2             = itemDataByItemId == null ? 0 : itemDataByItemId.Num;
                rewardData1.ItemsBeforeAmount.Add(num2);
                if (itemListEntity.Item.HaveCap < itemListEntity.Num)
                {
                    itemListEntity.Item.Gain(itemListEntity.Item.HaveCap);
                    rewardData1.Items.Add(itemListEntity.Item);
                    int      num3     = itemListEntity.Num - itemListEntity.Item.HaveCap;
                    ItemData itemData = new ItemData();
                    if (itemData.Setup(itemListEntity.Item.UniqueID, itemListEntity.Item.Param, num3))
                    {
                        rewardData1.Items.Add(itemData);
                        rewardData1.ItemsBeforeAmount.Add(itemData.HaveCap);
                    }
                }
                else
                {
                    itemListEntity.Item.Gain(itemListEntity.Num - itemListEntity.Item.Num);
                    rewardData1.Items.Add(itemListEntity.Item);
                }
            }
            GlobalVars.LastReward.Set(rewardData1);
            this.UpdateItems();
        }
Ejemplo n.º 28
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);
        }
Ejemplo n.º 29
0
        private void UpdateItems()
        {
            if (Object.op_Equality((Object)this.ItemTemplate, (Object)null))
            {
                return;
            }
            if (this.mItems != null)
            {
                for (int index = 0; index < this.mReadMails.Count; ++index)
                {
                    this.mReadMails[index].SetActive(false);
                }
                for (int index = 0; index < this.mUnreadMails.Count; ++index)
                {
                    this.mUnreadMails[index].SetActive(false);
                }
                this.mReadMails.Clear();
                this.mUnreadMails.Clear();
                for (int index = 0; index < this.mItems.Count; ++index)
                {
                    Object.Destroy((Object)this.mItems[index].get_gameObject());
                }
            }
            List <MailData> mails     = MonoSingleton <GameManager> .Instance.Player.Mails;
            Transform       transform = ((Component)this).get_transform();

            this.mItems       = new List <GameObject>(mails.Count);
            this.mReadMails   = new List <GameObject>();
            this.mUnreadMails = new List <GameObject>();
            for (int index1 = mails.Count - 1; index1 >= 0; --index1)
            {
                MailData   data1       = mails[index1];
                GameObject gameObject1 = this.ItemTemplate;
                if (data1.IsPeriod)
                {
                    gameObject1 = this.ItemTemplate;
                }
                else if (Object.op_Inequality((Object)this.ItemForeverTemplate, (Object)null))
                {
                    gameObject1 = this.ItemForeverTemplate;
                }
                GameObject gameObject2 = (GameObject)Object.Instantiate <GameObject>((M0)gameObject1);
                gameObject2.get_transform().SetParent(transform, false);
                int num = 0;
                for (int index2 = 0; index2 < data1.gifts.Length; ++index2)
                {
                    GiftData gift = data1.gifts[index2];
                    if (gift.num > 0)
                    {
                        ++num;
                    }
                    if (gift.coin > 0)
                    {
                        ++num;
                    }
                    if (gift.gold > 0)
                    {
                        ++num;
                    }
                    if (gift.arenacoin > 0)
                    {
                        ++num;
                    }
                    if (gift.multicoin > 0)
                    {
                        ++num;
                    }
                    if (gift.kakeracoin > 0)
                    {
                        ++num;
                    }
                }
                if (num >= 2)
                {
                    MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                    if (Object.op_Inequality((Object)component, (Object)null))
                    {
                        component.CurrentIcon = component.SetIconTemplate;
                        component.CurrentIcon.SetActive(true);
                    }
                }
                else
                {
                    for (int index2 = 0; index2 < data1.gifts.Length; ++index2)
                    {
                        GiftData gift = data1.gifts[index2];
                        if (gift.num > 0)
                        {
                            if (gift.CheckGiftTypeIncluded(GiftTypes.Artifact))
                            {
                                ArtifactData artifactData = this.CreateArtifactData(gift.iname);
                                if (artifactData != null)
                                {
                                    DataSource.Bind <ArtifactData>(gameObject2, artifactData);
                                }
                                MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                                if (Object.op_Inequality((Object)component, (Object)null))
                                {
                                    component.CurrentIcon = component.ArtifactIconTemplate;
                                    component.CurrentIcon.SetActive(true);
                                    break;
                                }
                                break;
                            }
                            if (gift.CheckGiftTypeIncluded(GiftTypes.Item))
                            {
                                ItemData data2 = new ItemData();
                                data2.Setup(0L, gift.iname, gift.num);
                                DataSource.Bind <ItemData>(gameObject2, data2);
                                MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                                if (Object.op_Inequality((Object)component, (Object)null))
                                {
                                    component.CurrentIcon = component.ItemIconTemplate;
                                    component.CurrentIcon.SetActive(true);
                                    break;
                                }
                                break;
                            }
                            break;
                        }
                        if (gift.coin > 0)
                        {
                            MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                            if (Object.op_Inequality((Object)component, (Object)null))
                            {
                                component.CurrentIcon = component.CoinIconTemplate;
                                component.CurrentIcon.SetActive(true);
                                break;
                            }
                            break;
                        }
                        if (gift.gold > 0)
                        {
                            MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                            if (Object.op_Inequality((Object)component, (Object)null))
                            {
                                component.CurrentIcon = component.GoldIconTemplate;
                                component.CurrentIcon.SetActive(true);
                            }
                        }
                        else if (gift.arenacoin > 0)
                        {
                            MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                            if (Object.op_Inequality((Object)component, (Object)null))
                            {
                                component.CurrentIcon = component.ArenaCoinIconTemplate;
                                component.CurrentIcon.SetActive(true);
                            }
                        }
                        else if (gift.multicoin > 0)
                        {
                            MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                            if (Object.op_Inequality((Object)component, (Object)null))
                            {
                                component.CurrentIcon = component.MultiCoinIconTemplate;
                                component.CurrentIcon.SetActive(true);
                            }
                        }
                        else if (gift.kakeracoin > 0)
                        {
                            MailIcon component = (MailIcon)gameObject2.GetComponent <MailIcon>();
                            if (Object.op_Inequality((Object)component, (Object)null))
                            {
                                component.CurrentIcon = component.KakeraCoinIconTemplate;
                                component.CurrentIcon.SetActive(true);
                            }
                        }
                    }
                }
                DataSource.Bind <MailData>(gameObject2, data1);
                GameObject gameObject3 = ((Component)gameObject2.get_transform().FindChild("btn_read")).get_gameObject();
                if (Object.op_Inequality((Object)gameObject3, (Object)null))
                {
                    DataSource.Bind <MailData>(gameObject3, data1);
                    Button component1 = (Button)gameObject3.GetComponent <Button>();
                    if (Object.op_Inequality((Object)component1, (Object)null))
                    {
                        ListItemEvents component2 = (ListItemEvents)((Component)component1).GetComponent <ListItemEvents>();
                        if (Object.op_Inequality((Object)component2, (Object)null))
                        {
                            component2.OnSelect = new ListItemEvents.ListItemEvent(this.OnSelect);
                        }
                    }
                }
                if (data1.read > 0L)
                {
                    this.mReadMails.Add(gameObject2);
                    gameObject2.SetActive(false);
                }
                else
                {
                    this.mUnreadMails.Add(gameObject2);
                    gameObject2.SetActive(true);
                }
                this.mItems.Add(gameObject2);
            }
        }
Ejemplo n.º 30
0
        private void Success()
        {
            PlayerData player = MonoSingleton <GameManager> .Instance.Player;

            if (Network.Mode == Network.EConnectMode.Offline)
            {
                for (int index = 0; index < this.mTrophyParam.Items.Length; ++index)
                {
                    player.GainItem(this.mTrophyParam.Items[index].iname, this.mTrophyParam.Items[index].Num);
                }
            }
            for (int index = 0; index < this.mTrophyParam.Items.Length; ++index)
            {
                player.OnItemQuantityChange(this.mTrophyParam.Items[index].iname, this.mTrophyParam.Items[index].Num);
            }
            player.OnCoinChange(this.mTrophyParam.Coin);
            player.OnGoldChange(this.mTrophyParam.Gold);
            if (player.Lv > this.mLevelOld)
            {
                player.OnPlayerLevelChange(player.Lv - this.mLevelOld);
            }
            GlobalVars.PlayerLevelChanged.Set(player.Lv != this.mLevelOld);
            GlobalVars.PlayerExpNew.Set(player.Exp);
            player.MarkTrophiesEnded(new TrophyParam[1]
            {
                this.mTrophyParam
            });
            if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.RewardWindow, (UnityEngine.Object)null))
            {
                RewardData data = new RewardData();
                data.Coin = this.mTrophyParam.Coin;
                data.Gold = this.mTrophyParam.Gold;
                data.Exp  = this.mTrophyParam.Exp;
                if (data.Coin > 0)
                {
                    AnalyticsManager.TrackFreePremiumCurrencyObtain((long)data.Coin, "Milestone Reward");
                }
                if (data.Gold > 0)
                {
                    AnalyticsManager.TrackNonPremiumCurrencyObtain(AnalyticsManager.NonPremiumCurrencyType.Zeni, (long)data.Gold, "Milestone Reward", (string)null);
                }
                GameManager instance = MonoSingleton <GameManager> .Instance;
                for (int index = 0; index < this.mTrophyParam.Items.Length; ++index)
                {
                    ItemData itemData = new ItemData();
                    if (itemData.Setup(0L, this.mTrophyParam.Items[index].iname, this.mTrophyParam.Items[index].Num))
                    {
                        data.Items.Add(itemData);
                        ItemData itemDataByItemId = instance.Player.FindItemDataByItemID(itemData.Param.iname);
                        int      num = itemDataByItemId == null ? 0 : itemDataByItemId.Num;
                        data.ItemsBeforeAmount.Add(num);
                        AnalyticsManager.TrackNonPremiumCurrencyObtain(itemDataByItemId.Param.type != EItemType.Ticket ? AnalyticsManager.NonPremiumCurrencyType.Item : AnalyticsManager.NonPremiumCurrencyType.SummonTicket, (long)itemDataByItemId.Num, "Milestone Reward", itemDataByItemId.ItemID);
                    }
                }
                DataSource.Bind <RewardData>(this.RewardWindow, data);
            }
            GameCenterManager.SendAchievementProgress(this.mTrophyParam.iname);
            if (this.mTrophyParam != null && this.mTrophyParam.Objectives != null)
            {
                for (int index = 0; index < this.mTrophyParam.Objectives.Length; ++index)
                {
                    if (this.mTrophyParam.Objectives[index].type == TrophyConditionTypes.followtwitter)
                    {
                        string reviewUrlTwitter = this.ReviewURL_Twitter;
                        if (!string.IsNullOrEmpty(reviewUrlTwitter))
                        {
                            Application.OpenURL(reviewUrlTwitter);
                            break;
                        }
                        break;
                    }
                }
            }
            ((Behaviour)this).set_enabled(false);
            this.ActivateOutputLinks(1);
        }