Exemplo n.º 1
0
        public RuneList GetRunes(region region, language lang, runeListData runeData = runeListData.basic, bool useCaching = false)
        {
            RuneList val = Cache.Get <RuneList>(region.ToString(), lang.ToString(), runeData.ToString()); //cache getting

            if (val != null)
            {
                return(val);
            }

            RiotApiCaller <RuneList> caller = new RiotApiCaller <RuneList>(suffix.runes);

            caller.AddParam(param.region, region);
            caller.AddParam(param.locale, lang);
            caller.AddParam(param.runeListData, runeData);

            if (useCaching)                                                               //your choice
            {
                Cache.AddOrUpdate(caller.CreateRequest(new System.TimeSpan(1, 0, 0, 0))); // cache adding
            }
            else
            {
                caller.CreateRequest();//everytime data coming from riotgames server
            }
            return(caller.Result.FirstOrDefault());
        }
Exemplo n.º 2
0
 public override void Fight()
 {
     base.Fight();
     if (Health > 0)
     {
         RuneList.Add(Factory.GenerateRandomRune());
     }
 }
Exemplo n.º 3
0
        public void GetRunes()
        {
            ApiService.ApiKey = APIKEY;//you must add your project, if you dont use ninject
            StaticApi staticapi = new StaticApi(new ApiCache());
            RuneList  data      = staticapi.GetRunes(region.tr, language.tr_TR, runeListData.all);

            Assert.IsNotNull(data);
        }
Exemplo n.º 4
0
        public StaticService(
            ILeagueApiConfiguration config)
            : base(config, VersionEnum.V1Rev2, "static-data", false)
        {
            ChampionList.CreateMap(AutoMapperService);
            ItemList.CreateMap(AutoMapperService);
            MasteryList.CreateMap(AutoMapperService);
            Realm.CreateMap(AutoMapperService);
            RuneList.CreateMap(AutoMapperService);
            SummonerSpellList.CreateMap(AutoMapperService);

#if DEBUG
            AutoMapperService.AssertConfigurationIsValid();
#endif
        }
        public ChandrallaAndBrightblaze(string name)
        {
            Name = name;
            switch (Factory.RNG.RandomDirection0To3())
            {
            case 0:
                XPosition = 0;
                YPosition = 0;
                break;

            case 1:
                XPosition = 7;
                YPosition = 0;
                break;

            case 2:
                XPosition = 7;
                YPosition = 10;
                break;

            case 3:
                XPosition = 0;
                YPosition = 10;
                break;
            }
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            Agility        = 10;
            Strength       = 5;
            Luck           = 7;
            Armour         = 6;
            StartingHealth = 14;
            Health         = StartingHealth;
            Players.Instance.AddPlayer(this);
        }
Exemplo n.º 6
0
        public BrotherGherkin(string name)
        {
            Name = name;
            switch (Factory.RNG.RandomDirection0To3())
            {
            case 0:
                XPosition = 0;
                YPosition = 0;
                break;

            case 1:
                XPosition = 7;
                YPosition = 0;
                break;

            case 2:
                XPosition = 7;
                YPosition = 10;
                break;

            case 3:
                XPosition = 0;
                YPosition = 10;
                break;
            }
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            Agility        = 7;
            Strength       = 8;
            Luck           = 11;
            Armour         = 9;
            StartingHealth = 15;
            Health         = StartingHealth;
            Players.Instance.AddPlayer(this);
        }
Exemplo n.º 7
0
        public HugoTheGlorious(string name)
        {
            Name = name;
            switch (Factory.RNG.RandomDirection0To3())
            {
            case 0:
                XPosition = 0;
                YPosition = 0;
                break;

            case 1:
                XPosition = 7;
                YPosition = 0;
                break;

            case 2:
                XPosition = 7;
                YPosition = 10;
                break;

            case 3:
                XPosition = 0;
                YPosition = 10;
                break;
            }
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            RuneList.Add(Factory.GenerateRandomRune());
            Agility        = 6;
            Strength       = 10;
            Luck           = 5;
            Armour         = 8;
            StartingHealth = 17;
            Health         = StartingHealth;
            Players.Instance.AddPlayer(this);
        }
        /// <summary>
        /// 初始化 卡牌、符文、技能-关卡 关系列表
        /// </summary>
        public void CardData_RuneData_SkillData_InitMapStageRelationLists()
        {
            var CardData  = new Dictionary <ParsedCardData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();
            var RuneData  = new Dictionary <ParsedRuneData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();
            var SkillData = new Dictionary <ParsedSkillData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();

            var CardRewardInMapStageLevelData     = new Dictionary <ParsedCardData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();
            var CardChipRewardInMapStageLevelData = new Dictionary <ParsedCardData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();
            var CardRewardInMapStageData          = new Dictionary <ParsedCardData, List <KeyValuePair <ParsedMapStageData, int> > >();
            var CardChipRewardInMapStageData      = new Dictionary <ParsedCardData, List <KeyValuePair <ParsedMapStageData, int> > >();

            var RuneRewardInMapStageLevelData = new Dictionary <ParsedRuneData, List <KeyValuePair <ParsedMapStageDetailLevelData, int> > >();
            var RuneRewardInMapStageData      = new Dictionary <ParsedRuneData, List <KeyValuePair <ParsedMapStageData, int> > >();

            void GetData(int difficulty, ParsedMapStageData[] MapStageList)
            {
                foreach (var ms in MapStageList)
                {
                    if (ms.OpenStatus == 0)
                    {
                        continue;
                    }
                    else
                    {
                        foreach (var msd in ms.MapStageDetails)
                        {
                            foreach (var msdl in msd.Levels)
                            {
                                //  遍历卡牌列表
                                foreach (var c in msdl.CardList)
                                {
                                    var a    = c.Split('_');
                                    var card = CardList.FirstOrDefault(m => m.CardId + "" == a[0] || m.CardName == a[0]);
                                    if (card == null)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        //  添加卡牌
                                        if (CardData.ContainsKey(card))
                                        {
                                            CardData[card].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                        }
                                        else
                                        {
                                            CardData.Add(card, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                            });
                                        }

                                        //  添加技能
                                        if (a.Length > 2)
                                        {
                                            var skill = SkillList.FirstOrDefault(m => m.SkillId + "" == a[2] || m.Name == a[2]);
                                            if (skill == null)
                                            {
                                                continue;
                                            }
                                            else
                                            {
                                                if (SkillData.ContainsKey(skill))
                                                {
                                                    SkillData[skill].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                                }
                                                else
                                                {
                                                    SkillData.Add(skill, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                        new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                                    });
                                                }
                                            }
                                        }
                                    }
                                }

                                //  遍历符文列表
                                foreach (var r in msdl.RuneList)
                                {
                                    var a    = r.Split('_');
                                    var rune = RuneList.FirstOrDefault(m => m.RuneId + "" == a[0] || m.RuneName == a[0]);
                                    if (rune == null)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        if (RuneData.ContainsKey(rune))
                                        {
                                            RuneData[rune].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                        }
                                        else
                                        {
                                            RuneData.Add(rune, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                            });
                                        }
                                    }
                                }

                                //  奖励列表
                                {
                                    var list = new List <string>();
                                    list.AddRange(msdl.BonusExplore);
                                    list.AddRange(msdl.BonusLose);
                                    list.AddRange(msdl.BonusWin);
                                    list.AddRange(msdl.FirstBonusWin);
                                    foreach (var i in list.Distinct())
                                    {
                                        var a = i.ToLower().Split('_');
                                        switch (a[0])
                                        {
                                        case "card":
                                        {
                                            var card = CardList.FirstOrDefault(m => m.CardId + "" == a[1] || m.CardName == a[1]);
                                            //  添加卡牌
                                            if (CardRewardInMapStageLevelData.ContainsKey(card))
                                            {
                                                CardRewardInMapStageLevelData[card].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                            }
                                            else
                                            {
                                                CardRewardInMapStageLevelData.Add(card, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                        new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                                    });
                                            }
                                            break;
                                        }

                                        case "rune":
                                        {
                                            var rune = RuneList.FirstOrDefault(m => m.RuneId + "" == a[1] || m.RuneName == a[1]);
                                            //  添加符文
                                            if (RuneRewardInMapStageLevelData.ContainsKey(rune))
                                            {
                                                RuneRewardInMapStageLevelData[rune].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                            }
                                            else
                                            {
                                                RuneRewardInMapStageLevelData.Add(rune, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                        new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                                    });
                                            }
                                            break;
                                        }
                                        }
                                    }

                                    //  卡牌碎片奖励
                                    if (msdl.BonusChip > 0)
                                    {
                                        var card = CardList.FirstOrDefault(m => m.CardId == msdl.BonusChip);
                                        //  添加卡牌
                                        if (CardChipRewardInMapStageLevelData.ContainsKey(card))
                                        {
                                            CardChipRewardInMapStageLevelData[card].Add(new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty));
                                        }
                                        else
                                        {
                                            CardChipRewardInMapStageLevelData.Add(card, new List <KeyValuePair <ParsedMapStageDetailLevelData, int> > {
                                                new KeyValuePair <ParsedMapStageDetailLevelData, int>(msdl, difficulty)
                                            });
                                        }
                                        break;
                                    }
                                }
                            }
                        }

                        //  通关奖励
                        {
                            foreach (var i in ms.FinishAward)
                            {
                                var a = i.ToLower().Split('_');
                                switch (a[0])
                                {
                                case "card":
                                {
                                    var card = CardList.FirstOrDefault(m => m.CardId + "" == a[1] || m.CardName == a[1]);
                                    //  添加卡牌
                                    if (CardRewardInMapStageData.ContainsKey(card))
                                    {
                                        CardRewardInMapStageData[card].Add(new KeyValuePair <ParsedMapStageData, int>(ms, difficulty));
                                    }
                                    else
                                    {
                                        CardRewardInMapStageData.Add(card, new List <KeyValuePair <ParsedMapStageData, int> > {
                                                new KeyValuePair <ParsedMapStageData, int>(ms, difficulty)
                                            });
                                    }
                                    break;
                                }

                                case "rune":
                                {
                                    var rune = RuneList.FirstOrDefault(m => m.RuneId + "" == a[1] || m.RuneName == a[1]);
                                    //  添加符文
                                    if (RuneRewardInMapStageData.ContainsKey(rune))
                                    {
                                        RuneRewardInMapStageData[rune].Add(new KeyValuePair <ParsedMapStageData, int>(ms, difficulty));
                                    }
                                    else
                                    {
                                        RuneRewardInMapStageData.Add(rune, new List <KeyValuePair <ParsedMapStageData, int> > {
                                                new KeyValuePair <ParsedMapStageData, int>(ms, difficulty)
                                            });
                                    }
                                    break;
                                }
                                }
                            }

                            //  通关探索碎片
                            foreach (var i in ms.HideChip.Where(m => m > 0))
                            {
                                var card = CardList.FirstOrDefault(m => m.CardId == i);
                                //  添加卡牌
                                if (CardChipRewardInMapStageData.ContainsKey(card))
                                {
                                    CardChipRewardInMapStageData[card].Add(new KeyValuePair <ParsedMapStageData, int>(ms, difficulty));
                                }
                                else
                                {
                                    CardChipRewardInMapStageData.Add(card, new List <KeyValuePair <ParsedMapStageData, int> > {
                                        new KeyValuePair <ParsedMapStageData, int>(ms, difficulty)
                                    });
                                }
                                break;
                            }
                        }
                    }
                }
            }

            GetData(0, MapStageList);
            GetData(1, MapHardStageList);

            var blank1 = new KeyValuePair <ParsedMapStageDetailLevelData, int>[] { };
            var blank2 = new KeyValuePair <ParsedMapStageData, int>[] { };

            void CopyList(dynamic fromListDictionary, dynamic toArrayDictionary, dynamic item, dynamic blankItem)
            {
                if (fromListDictionary.ContainsKey(item))
                {
                    toArrayDictionary.Add(item, fromListDictionary[item].ToArray());
                }
                else
                {
                    toArrayDictionary.Add(item, blankItem);
                }
            }

            foreach (var c in CardList)
            {
                CopyList(CardData, CardData_ShowInMapStageLevel, c, blank1);

                CopyList(CardRewardInMapStageLevelData, CardData_RewardInMapStageLevel, c, blank1);
                CopyList(CardChipRewardInMapStageLevelData, CardData_ChipRewardInMapStageLevel, c, blank1);
                CopyList(CardRewardInMapStageData, CardData_RewardInMapStage, c, blank2);
                CopyList(CardChipRewardInMapStageData, CardData_ChipRewardInMapStage, c, blank2);
            }
            foreach (var r in RuneList)
            {
                CopyList(RuneData, RuneData_ShowInMapStageLevel, r, blank1);

                CopyList(RuneRewardInMapStageLevelData, RuneData_RewardInMapStageLevel, r, blank1);
                CopyList(RuneRewardInMapStageData, RuneData_RewardInMapStage, r, blank2);
            }
            foreach (var s in SkillList)
            {
                CopyList(SkillData, SkillData_ShowInMapStageLevel, s, blank1);
            }
        }