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);
 }

        private async void TransferPokemon(PokemonData pokemon)
        {
            if (MessageBox.Show($"Are you sure you want to transfer {pokemon.PokemonId.ToString()} with {pokemon.Cp} CP?", "Confirmation", MessageBoxButtons.YesNo) == DialogResult.Yes)
            {
                var transferPokemonResponse = await client2.TransferPokemon(pokemon.Id);

                if (transferPokemonResponse.Status == 1)
                {
                    ColoredConsoleWrite(Color.Magenta, $"{pokemon.PokemonId} was transferred. {transferPokemonResponse.CandyAwarded} candy awarded");
                    ReloadPokemonList();
                }
                else
                {
                    ColoredConsoleWrite(Color.Magenta, $"{pokemon.PokemonId} could not be transferred");
                }
            }
        }

 public static PokemonMove GetPokemonMove1(PokemonData poke)
 {
     var move1 = poke.Move1;
     return move1;
 }

        public static int GetCandy(PokemonData pokemon, List<Candy> PokemonFamilies, IEnumerable<PokemonSettings> PokemonSettings)
        {
            var setting = PokemonSettings.FirstOrDefault(q => pokemon != null && q.PokemonId.Equals(pokemon.PokemonId));
            var family = PokemonFamilies.FirstOrDefault(q => setting != null && q.FamilyId.Equals(setting.FamilyId));

            return family.Candy_;
        }

 public static double GetLevel(PokemonData poke)
 {
     switch ((int) ((poke.CpMultiplier + poke.AdditionalCpMultiplier)*1000.0))
     {
         case 93: // 0.094 * 1000 = 93.99999678134
         case 94:
             return 1;
         case 135:
             return 1.5;
         case 166:
             return 2;
         case 192:
             return 2.5;
         case 215:
             return 3;
         case 236:
             return 3.5;
         case 255:
             return 4;
         case 273:
             return 4.5;
         case 290:
             return 5;
         case 306:
             return 5.5;
         case 321:
             return 6;
         case 335:
             return 6.5;
         case 349:
             return 7;
         case 362:
             return 7.5;
         case 375:
             return 8;
         case 387:
             return 8.5;
         case 399:
             return 9;
         case 411:
             return 9.5;
         case 422:
             return 10;
         case 432:
             return 10.5;
         case 443:
             return 11;
         case 453:
             return 11.5;
         case 462:
             return 12;
         case 472:
             return 12.5;
         case 481:
             return 13;
         case 490:
             return 13.5;
         case 499:
             return 14;
         case 508:
             return 14.5;
         case 517:
             return 15;
         case 525:
             return 15.5;
         case 534:
             return 16;
         case 542:
             return 16.5;
         case 550:
             return 17;
         case 558:
             return 17.5;
         case 566:
             return 18;
         case 574:
             return 18.5;
         case 582:
             return 19;
         case 589:
             return 19.5;
         case 597:
             return 20;
         case 604:
             return 20.5;
         case 612:
             return 21;
         case 619:
             return 21.5;
         case 626:
             return 22;
         case 633:
             return 22.5;
         case 640:
             return 23;
         case 647:
             return 23.5;
         case 654:
             return 24;
         case 661:
//.........这里部分代码省略.........

        private static async Task evolvePokemon(PokemonData pokemon)
        {
            try
            {
                var evolvePokemonResponse = await client.EvolvePokemon(pokemon.Id);
                string message = "";
                string caption = "";
                MessageBoxButtons buttons = MessageBoxButtons.OK;
                DialogResult result;

                if (evolvePokemonResponse.Result == 1)
                {
                    message = $"{pokemon.PokemonId} successfully evolved into {evolvePokemonResponse.EvolvedPokemon.PokemonType}\n{evolvePokemonResponse.ExpAwarded} experience awarded\n{evolvePokemonResponse.CandyAwarded} candy awarded";
                    caption = $"{pokemon.PokemonId} evolved into {evolvePokemonResponse.EvolvedPokemon.PokemonType}";
                }
                else
                {
                    message = $"{pokemon.PokemonId} could not be evolved";
                    caption = $"Evolve {pokemon.PokemonId} failed";
                }

                result = MessageBox.Show(message, caption, buttons, MessageBoxIcon.Information);
            }
            catch (TaskCanceledException) { await evolvePokemon(pokemon); }
            catch (UriFormatException) { await evolvePokemon(pokemon); }
            catch (ArgumentOutOfRangeException) { await evolvePokemon(pokemon); }
            catch (ArgumentNullException) { await evolvePokemon(pokemon); }
            catch (NullReferenceException) { await evolvePokemon(pokemon); }
            catch (Exception ex) { await evolvePokemon(pokemon); }
        }