C# PokemonData类代码示例

        public Client(ClientIdentifier id)
        {
            Id = id;

            var stats = new Stats { Atk = 10, Def = 10, HP = 30, SpAtk = 10, SpDef = 10, Speed = 10 };
            var data = new PokemonData { Id = 0, Type1 = PokemonType.Normal, BaseStats = stats };

            var moveData = new MoveData
            {
                Name = "Move",
                Accuracy = 100,
                Damage = 120,
                DamageType = DamageCategory.Physical,
                PokemonType = PokemonType.Normal,
                PP = 20
            };

            for (int i = 0; i < 6; i++)
            {
                var pkmn = new Pokemon(data, stats) { Name = Id.Name + "_Pkmn" + i, Level = i + 20};
                for (int j = 0; j < 2; j++)
                    pkmn.SetMove(j, new Move(moveData));
                pkmn.Stats.HP = 30;
                pkmn.HP = 30;

                pokemons.Add(pkmn);
            }
        }

 public static double CalculateCpMultiplier(PokemonData poke)
 {
     var baseStats = GetBaseStats(poke.PokemonId);
     return (baseStats.BaseAttack + poke.IndividualAttack)*
            Math.Sqrt(baseStats.BaseDefense + poke.IndividualDefense)*
            Math.Sqrt(baseStats.BaseStamina + poke.IndividualStamina);
 }

 public static float CalculatePokemonPerfection(PokemonData poke)
 {
     if (poke != null)
         return (poke.IndividualAttack * 2 + poke.IndividualDefense + poke.IndividualStamina) / (4.0f * 15.0f) * 100.0f;
     else
         return 0;
 }

        public static async Task PokemonCaught(PokemonData poke)
        {

            OnPokemonCaught(null, new PokemonCaughtArgs() { CaughtPokemon = poke });

            await PokemonCaughtReset.WaitAsync();
            PokemonCaughtReset.Reset();
        }

 public async Task<int> GetHighestCPofType(PokemonData pokemon)
 {
     var myPokemon = await GetPokemons();
     var pokemons = myPokemon.ToList();
     return pokemons.Where(x => x.PokemonId == pokemon.PokemonId)
         .OrderByDescending(x => x.Cp)
         .First().Cp;
 }

 public static int CalculateMinCp(PokemonData poke)
 {
     return
         Math.Max(
             (int)
                 Math.Floor(0.1*CalculateMinCpMultiplier(poke)*
                            Math.Pow(poke.CpMultiplier + poke.AdditionalCpMultiplier, 2)), 10);
 }

 public async Task<IEnumerable<PokemonData>> GetHighestIVofType(PokemonData pokemon)
 {
     var myPokemon = await GetPokemons();
     var pokemons = myPokemon.ToList();
     return pokemons.Where(x => x.PokemonId == pokemon.PokemonId)
             .OrderByDescending(PokemonInfo.CalculatePokemonPerfection)
             .ThenBy(x => x.Cp)
             .ToList();
 }

        public static double CalculatePokemonPerfection(PokemonData poke)
        {
            if (Math.Abs(poke.CpMultiplier + poke.AdditionalCpMultiplier) <= 0)
                return (poke.IndividualAttack * 2 + poke.IndividualDefense + poke.IndividualStamina) / (4.0 * 15.0) * 100.0;

            var maxCp = CalculateMaxCpMultiplier(poke);
            var minCp = CalculateMinCpMultiplier(poke);
            var curCp = CalculateCpMultiplier(poke);

            return ((curCp - minCp) / (maxCp - minCp)) * 100.0;
        }

        public static double CalculatePokemonPerfection(PokemonData poke)
        {
            if (poke.CpMultiplier + poke.AdditionalCpMultiplier == 0)
                return (poke.IndividualAttack * 2 + poke.IndividualDefense + poke.IndividualStamina) / (4.0 * 15.0) * 100.0;

            BaseStats baseStats = GetBaseStats(poke.PokemonId);
            var max_cp = CalculateMaxCPMultiplier(poke);
            var min_cp = CalculateMinCPMultiplier(poke);
            var cur_cp = CalculateCPMultiplier(poke);

            return ((cur_cp - min_cp) / (max_cp - min_cp)) * 100.0;
        }

        public async Task<TransferStatus> Transfer(PokemonData pokemon, float keepPerfectPokemonLimit = 80.0f)
        {
            if (Perfect(pokemon) >= keepPerfectPokemonLimit || pokemon.Favorite == 0) return TransferStatus.Ignored;

            var transferPokemonResponse = await PokemonClient.TransferPokemon(pokemon.Id);

            await Task.Delay(3000);
            if (transferPokemonResponse.Status == 1)
            {
                return TransferStatus.Success;
            }

            return TransferStatus.Fail;
        }

 protected void HandleEvent(PokemonData pokemon, TransferStatus status)
 {
     if (status == TransferStatus.Success)
     {
         OnTransferSuccess(pokemon);
     }
     else if (status == TransferStatus.Fail)
     {
         OnTransferFailed(pokemon);
     }
     else if(status == TransferStatus.Ignored)
     {
         OnTransferIgnored(pokemon);
     }
 }

        public Pokemon FromPokemonData(PokemonData data)
        {
            if (data == null)
                return null;

            //var iStats = GenerateIV();

//            var stats = new Stats
//            {
//                HP = data.BaseStats.HP + iStats.HP,
//                Atk = data.BaseStats.Atk + iStats.Atk,
//                Def = data.BaseStats.Def + iStats.Def,
//                SpAtk = data.BaseStats.SpAtk + iStats.SpAtk,
//                SpDef = data.BaseStats.SpDef + iStats.SpDef,
//                Speed = data.BaseStats.Speed + iStats.Speed
//            };

            //var builder = new PokemonBuilder(data);
            //builder.SetIV (iStats).SetStats (stats);
            //return builder.Build ();
            throw new NotImplementedException();
        }

 public async Task<PokemonData> GetHighestPokemonOfTypeByCp(PokemonData pokemon)
 {
     var myPokemon = await GetPokemons();
     var pokemons = myPokemon.ToList();
     return pokemons.Where(x => x.PokemonId == pokemon.PokemonId)
         .OrderByDescending(x => x.Cp)
         .FirstOrDefault();
 }

 public static PokemonMove GetPokemonMove2(PokemonData poke)
 {
     var move2 = poke.Move2;
     return move2;
 }

 public static int GetPowerUpLevel(PokemonData poke)
 {
     return (int) (GetLevel(poke)*2.0);
 }