コード例 #1
0
        public async Task GetEvolutionTriggerResourceAsyncIntegrationTest()
        {
            // assemble
            PokeApiClient client = new PokeApiClient();

            // act
            EvolutionTrigger evolutionTrigger = await client.GetResourceAsync <EvolutionTrigger>(1);

            // assert
            Assert.True(evolutionTrigger.Id != default(int));
        }
コード例 #2
0
        /// <summary>
        /// Returns the evolution of a Pokémon. Returns 0 if not successful
        /// </summary>
        /// <param name="p">The Pokémon to get the evolution from.</param>
        /// <param name="trigger">The trigger that triggered the evolution.</param>
        /// <param name="arg">An argument (for example Item ID)</param>
        public static int EvolutionNumber(BasePokemon p, EvolutionTrigger trigger, string arg)
        {
            if (trigger == EvolutionTrigger.LevelUp || trigger == EvolutionTrigger.Trading)
            {
                if ((p.Item != null))
                {
                    if (p.Item.Id == 112)
                    {
                        return(0);
                    }
                }
            }

            List <int> possibleEvolutions = new List <int>();

            foreach (EvolutionCondition e in p.EvolutionConditions)
            {
                bool canEvolve = true;

                foreach (Condition c in e.Conditions)
                {
                    if (c.Trigger != trigger)
                    {
                        canEvolve = false;
                    }
                }

                if (canEvolve)
                {
                    foreach (Condition c in e.Conditions)
                    {
                        switch (c.ConditionType)
                        {
                        case ConditionTypes.AtkDef:
                            if (p.Attack <= p.Defense)
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.DayTime:
                            List <string> daytimes = c.Argument.Split(Convert.ToChar(";")).ToList();

                            if (!daytimes.Contains(Convert.ToString(Convert.ToInt32(BaseWorld.GetTime))))
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.DefAtk:
                            if (p.Defense <= p.Attack)
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.DefEqualsAtk:
                            if (p.Attack != p.Defense)
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Friendship:
                            if (p.Friendship < Convert.ToInt32(c.Argument))
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Gender:
                            if ((int)p.Gender != Convert.ToInt32(c.Argument))
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.HoldItem:
                            if (p.Item == null)
                            {
                                canEvolve = false;
                            }
                            else
                            {
                                if (p.Item.Id != Convert.ToInt32(c.Argument))
                                {
                                    canEvolve = false;
                                }
                            }
                            break;

                        case ConditionTypes.InParty:
                        {
                            bool isInParty = false;
                            foreach (var pokemon in Core.Player.Pokemons)
                            {
                                if (pokemon.Number == Convert.ToInt32(c.Argument))
                                {
                                    isInParty = true;
                                    break;     // TODO: might not be correct. Was : Exit For
                                }
                            }

                            if (isInParty == false)
                            {
                                canEvolve = false;
                            }
                        }
                        break;

                        case ConditionTypes.InPartyType:
                        {
                            bool isInParty = false;
                            foreach (var pokemon in Core.Player.Pokemons)
                            {
                                if (pokemon.IsType(new Element(c.Argument).Type) == true)
                                {
                                    isInParty = true;
                                    break;     // TODO: might not be correct. Was : Exit For
                                }
                            }

                            if (isInParty == false)
                            {
                                canEvolve = false;
                            }
                        }
                        break;

                        case ConditionTypes.Item:
                            if (Convert.ToInt32(arg) != Convert.ToInt32(c.Argument))
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Level:
                            if (p.Level < Convert.ToInt32(c.Argument))
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Move:
                            bool hasattack = false;
                            foreach (var a in p.Attacks)
                            {
                                if (a.Id == Convert.ToInt32(c.Argument))
                                {
                                    hasattack = true;
                                    break;     // TODO: might not be correct. Was : Exit For
                                }
                            }

                            if (hasattack == false)
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Place:
                            if (Screen.Level.MapName.ToLower() != c.Argument.ToLower())
                            {
                                canEvolve = false;
                            }
                            break;

                        case ConditionTypes.Trade:
                            if (c.Argument.IsNumeric())
                            {
                                if (Convert.ToInt32(c.Argument) > 0)
                                {
                                    if (Convert.ToInt32(c.Argument) != Convert.ToInt32(arg))
                                    {
                                        canEvolve = false;
                                    }
                                }
                            }
                            break;

                        case ConditionTypes.Weather:
                            if (BaseWorld.GetCurrentRegionWeather().ToString().ToLower() != c.Argument.ToLower())
                            {
                                canEvolve = false;
                            }
                            break;
                        }
                    }
                }

                if (canEvolve == true)
                {
                    possibleEvolutions.Add(e.Evolution);
                }
            }

            if (possibleEvolutions.Count > 0)
            {
                return(possibleEvolutions[Core.Random.Next(0, possibleEvolutions.Count)]);
            }

            return(0);
        }