Beispiel #1
0
        public static Common.PossibilitySet.Possibility[] GetEncounterPossibilities(PokemonTranslator pokemonTranslator, int level)
        {
            Dictionary <int, List <Common.PossibilitySet.Possibility.IV> > IVs = new Dictionary <int, List <Common.PossibilitySet.Possibility.IV> >();

            for (int attack = PokeConstants.MinRaidBossIV; attack <= PokeConstants.Evaluation.Attribute.Max; attack++)
            {
                for (int defense = PokeConstants.MinRaidBossIV; defense <= PokeConstants.Evaluation.Attribute.Max; defense++)
                {
                    for (int stamina = PokeConstants.MinRaidBossIV; stamina <= PokeConstants.Evaluation.Attribute.Max; stamina++)
                    {
                        Common.IVScore pokemonIV = new Common.IVScore(attack, defense, stamina);
                        Common.IVScore baseIV    = new Common.IVScore(pokemonTranslator.PokemonSettings.stats);

                        int cp = PokeFormulas.GetPokemonCP(baseIV, pokemonIV, level);
                        int hp = PokeFormulas.GetPokemonHP(baseIV.stamina, stamina, level);
                        if (!IVs.ContainsKey(cp))
                        {
                            IVs.Add(cp, new List <Common.PossibilitySet.Possibility.IV>());
                        }
                        IVs[cp].Add(new Common.PossibilitySet.Possibility.IV(pokemonIV, hp));
                    }
                }
            }

            List <Common.PossibilitySet.Possibility> possibilities = new List <Common.PossibilitySet.Possibility>();

            foreach (var ivs in IVs)
            {
                possibilities.Add(new Common.PossibilitySet.Possibility(ivs.Key, ivs.Value.ToArray()));
            }

            return(possibilities.ToArray());
        }
Beispiel #2
0
        public void Update(MoveSets._Pokemon pokemonMoveSets)
        {
            try
            {
                int gen = PokeFormulas.GetGeneration(pokemonMoveSets.id);

                foreach (var moveSet in pokemonMoveSets.MoveSet)
                {
                    _moveSetsStats[0].count++;
                    _moveSetsStats[gen].count++;
                    _moveSetsStats[0].totalDPS       += moveSet.base_dps;
                    _moveSetsStats[gen].totalDPS     += moveSet.base_dps;
                    _moveSetsStats[0].totalTrueDPS   += moveSet.true_dps;
                    _moveSetsStats[gen].totalTrueDPS += moveSet.true_dps;

                    GameMasterStats.MoveSets[0].dps_max        = Math.Max(GameMasterStats.MoveSets[0].dps_max, moveSet.base_dps);
                    GameMasterStats.MoveSets[gen].dps_max      = Math.Max(GameMasterStats.MoveSets[gen].dps_max, moveSet.base_dps);
                    GameMasterStats.MoveSets[0].true_dps_max   = Math.Max(GameMasterStats.MoveSets[0].true_dps_max, moveSet.true_dps);
                    GameMasterStats.MoveSets[gen].true_dps_max = Math.Max(GameMasterStats.MoveSets[gen].true_dps_max, moveSet.true_dps);
                    GameMasterStats.MoveSets[0].dps_avg        = _moveSetsStats[0].totalDPS / _moveSetsStats[0].count;
                    GameMasterStats.MoveSets[gen].dps_avg      = _moveSetsStats[gen].totalDPS / _moveSetsStats[gen].count;
                    GameMasterStats.MoveSets[0].true_dps_avg   = _moveSetsStats[0].totalTrueDPS / _moveSetsStats[0].count;
                    GameMasterStats.MoveSets[gen].true_dps_avg = _moveSetsStats[gen].totalTrueDPS / _moveSetsStats[gen].count;
                }
                //Console.Out.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}", _moveSetsStats[gen].count, moveSet.base_dps, _moveSetsStats[gen].totalDPS, GameMasterStats.MoveSets[gen].dps_max, GameMasterStats.MoveSets[0].dps_avg);
            }
            catch (Exception ex)
            {
                ConsoleOutput.OutputException(ex, "Error calculating MoveSet Stats.");
            }
        }
Beispiel #3
0
        public void Update(PokemonUnreleased._Pokemon pokemon)
        {
            int gen = PokeFormulas.GetGeneration(pokemon.id);

            GameMasterStats.PokemonCount[0].total++;
            GameMasterStats.PokemonCount[gen].total++;
        }
Beispiel #4
0
        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="gameMaster"></param>
        /// <param name="legacyGameMasters"></param>
        /// <param name="rootFolder"></param>
        public GameMasterDataWriter(GameMasterTemplate gameMasterTemplate, IEnumerable <GameMasterTemplate> legacyGameMasterTemplates)
        {
            // Read the config.
            ManualDataSettings = new ManualDataSettings(Utils.InputManualDataFileFolder);

            GameMasterStatsCalculator = new GameMasterStatsCalculator(gameMasterTemplate.FileName);

            CollectData(gameMasterTemplate, legacyGameMasterTemplates);

            PokeFormulas.Init(PlayerLevel);
            ManualDataSettings.RaidBosses.Init(Pokemon);
            ManualDataSettings.Encounters.Init(Pokemon);
            ManualDataSettings.SpecialResearch.Init(Pokemon);
            ManualDataSettings.EventResearch.Init(Pokemon);
        }
Beispiel #5
0
        public void Update(PokeStats._Pokemon pokemon)
        {
            int gen = PokeFormulas.GetGeneration(pokemon.id);

            GameMasterStats.gens_released = Math.Max(gen, GameMasterStats.gens_released);

            GameMasterStats.PokemonCount[0].total++;
            GameMasterStats.PokemonCount[gen].total++;

            if (!string.Equals(pokemon.availability, PokeConstants.Availability.Unreleased, StringComparison.OrdinalIgnoreCase))
            {
                GameMasterStats.PokemonCount[0].available++;
                GameMasterStats.PokemonCount[gen].available++;

                if (pokemon.availability != null && (
                        pokemon.availability.IndexOf(PokeConstants.Availability.Regional, StringComparison.OrdinalIgnoreCase) == -1 ||
                        pokemon.availability.IndexOf(PokeConstants.Availability.Region.UnitedStates, StringComparison.OrdinalIgnoreCase) != -1 ||
                        pokemon.availability.IndexOf(PokeConstants.Availability.Region.Americas, StringComparison.OrdinalIgnoreCase) != -1))
                {
                    GameMasterStats.PokemonCount[0].available_wa++;
                    GameMasterStats.PokemonCount[gen].available_wa++;
                }
            }
        }