Added class GameData::Evolution, moved evolution-related methods to more appropriate places

Data/Scripts/011_Data/001_PBS data/010_Species.rb

@@ -110,7 +110,7 @@ module GameData
       }
       if compiling_forms
         ret["PokedexForm"]  = [0, "u"]
-        ret["Evolutions"]   = [0, "*ees", :Species, :PBEvolution, nil]
+        ret["Evolutions"]   = [0, "*ees", :Species, :Evolution, nil]
         ret["MegaStone"]    = [0, "e", :Item]
         ret["MegaMove"]     = [0, "e", :Move]
         ret["UnmegaForm"]   = [0, "u"]
@@ -121,7 +121,7 @@ module GameData
         ret["GrowthRate"]   = [0, "e", :GrowthRate]
         ret["GenderRate"]   = [0, "e", :GenderRatio]
         ret["Incense"]      = [0, "e", :Item]
-        ret["Evolutions"]   = [0, "*ses", nil, :PBEvolution, nil]
+        ret["Evolutions"]   = [0, "*ses", nil, :Evolution, nil]
       end
       return ret
     end
@@ -221,6 +221,98 @@ module GameData
       return true
 #      return @front_sprite_altitude > 0
     end
+
+    def get_evolutions(exclude_invalid = false)
+      ret = []
+      @evolutions.each do |evo|
+        next if evo[3]   # Is the prevolution
+        next if evo[1] == :None && exclude_invalid
+        ret.push([evo[0], evo[1], evo[2]])   # [Species, method, parameter]
+      end
+      return ret
+    end
+
+    def get_family_evolutions(exclude_invalid = true)
+      evos = self.get_evolutions(exclude_invalid)
+      evos = evos.sort { |a, b| GameData::Species.get(a[0]).id_number <=> GameData::Species.get(b[0]).id_number }
+      ret = []
+      evos.each do |evo|
+        ret.push([@species].concat(evo))   # [Prevo species, evo species, method, parameter]
+        evo_array = GameData::Species.get(evo[0]).get_family_evolutions(exclude_invalid)
+        ret.concat(evo_array) if evo_array && evo_array.length > 0
+      end
+      return ret
+    end
+
+    def get_previous_species
+      return @species if @evolutions.length == 0
+      @evolutions.each { |evo| return evo[0] if evo[3] }   # Is the prevolution
+      return @species
+    end
+
+    def get_baby_species(check_items = false, item1 = nil, item2 = nil)
+      ret = @species
+      return ret if @evolutions.length == 0
+      @evolutions.each do |evo|
+        next if !evo[3]   # Not the prevolution
+        if check_items
+          incense = GameData::Species.get(evo[0]).incense
+          ret = evo[0] if !incense || item1 == incense || item2 == incense
+        else
+          ret = evo[0]   # Species of prevolution
+        end
+        break
+      end
+      ret = GameData::Species.get(ret).get_baby_species(check_items, item1, item2) if ret != @species
+      return ret
+    end
+
+    def get_related_species
+      sp = self.get_baby_species
+      evos = GameData::Species.get(sp).get_family_evolutions(false)
+      return [sp] if evos.length == 0
+      return [sp].concat(evos.map { |e| e[1] }).uniq
+    end
+
+    def family_evolutions_have_method?(check_method, check_param = nil)
+      sp = self.get_baby_species
+      evos = GameData::Species.get(sp).get_family_evolutions
+      return false if evos.length == 0
+      evos.each do |evo|
+        if check_method.is_a?(Array)
+          next if !check_method.include?(evo[2])
+        else
+          next if evo[2] != check_method
+        end
+        return true if check_param.nil? || evo[3] == check_param
+      end
+      return false
+    end
+
+    # Used by the Moon Ball when checking if a Pokémon's evolution family
+    # includes an evolution that uses the Moon Stone.
+    def family_item_evolutions_use_item?(check_item = nil)
+      sp = self.get_baby_species
+      evos = GameData::Species.get(sp).get_family_evolutions
+      return false if !evos || evos.length == 0
+      evos.each do |evo|
+        next if GameData::Evolution.get(evo[2]).use_item_proc.nil?
+        return true if check_item.nil? || evo[3] == check_item
+      end
+      return false
+    end
+
+    def minimum_level
+      return 1 if @evolutions.length == 0
+      @evolutions.each do |evo|
+        next if !evo[3]   # Not the prevolution
+        evo_method_data = GameData::Evolution.get(evo[1])
+        next if evo_method_data.level_up_proc.nil?
+        min_level = evo_method_data.minimum_level
+        return (min_level == 0) ? evo[2] : min_level + 1
+      end
+      return 1
+    end
   end
 end
 
@@ -262,3 +354,45 @@ def showShadow?(species)
   Deprecation.warn_method('showShadow?', 'v20', 'GameData::Species.get(species).shows_shadow?')
   return GameData::Species.get(species).shows_shadow?
 end
+
+# @deprecated Use {GameData#Species#get_evolutions} instead. This alias is slated to be removed in v20.
+def pbGetEvolvedFormData(species, exclude_invalid = false)
+  Deprecation.warn_method('pbGetEvolvedFormData', 'v20', 'GameData::Species.get(species).get_evolutions')
+  return GameData::Species.get(species).get_evolutions(exclude_invalid)
+end
+
+# @deprecated Use {GameData#Species#get_family_evolutions} instead. This alias is slated to be removed in v20.
+def pbGetEvolutionFamilyData(species)   # Unused
+  Deprecation.warn_method('pbGetEvolutionFamilyData', 'v20', 'GameData::Species.get(species).get_family_evolutions')
+  return GameData::Species.get(species).get_family_evolutions
+end
+
+# @deprecated Use {GameData#Species#get_previous_species} instead. This alias is slated to be removed in v20.
+def pbGetPreviousForm(species)   # Unused
+  Deprecation.warn_method('pbGetPreviousForm', 'v20', 'GameData::Species.get(species).get_previous_species')
+  return GameData::Species.get(species).get_previous_species
+end
+
+# @deprecated Use {GameData#Species#get_baby_species} instead. This alias is slated to be removed in v20.
+def pbGetBabySpecies(species, check_items = false, item1 = nil, item2 = nil)
+  Deprecation.warn_method('pbGetBabySpecies', 'v20', 'GameData::Species.get(species).get_baby_species')
+  return GameData::Species.get(species).get_baby_species(check_items, item1, item2)
+end
+
+# @deprecated Use {GameData#Species#family_evolutions_have_method?} instead. This alias is slated to be removed in v20.
+def pbCheckEvolutionFamilyForMethod(species, method, param = nil)   # Unused
+  Deprecation.warn_method('pbCheckEvolutionFamilyForMethod', 'v20', 'GameData::Species.get(species).family_evolutions_have_method?(method)')
+  return GameData::Species.get(species).family_evolutions_have_method?(method, param)
+end
+
+# @deprecated Use {GameData#Species#family_item_evolutions_use_item?} instead. This alias is slated to be removed in v20.
+def pbCheckEvolutionFamilyForItemMethodItem(species, param = nil)
+  Deprecation.warn_method('pbCheckEvolutionFamilyForItemMethodItem', 'v20', 'GameData::Species.get(species).family_item_evolutions_use_item?(item)')
+  return GameData::Species.get(species).family_item_evolutions_use_item?(param)
+end
+
+# @deprecated Use {GameData#Species#minimum_level} instead. This alias is slated to be removed in v20.
+def pbGetMinimumLevel(species)
+  Deprecation.warn_method('pbGetMinimumLevel', 'v20', 'GameData::Species.get(species).minimum_level')
+  return GameData::Species.get(species).minimum_level
+end

Data/Scripts/011_Data/002_Hardcoded data/001_GrowthRate.rb

@@ -72,6 +72,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::GrowthRate.register({
   :id          => :Medium,   # Also known as Medium Fast
   :name        => _INTL("Medium"),

Data/Scripts/011_Data/002_Hardcoded data/002_Stat.rb

@@ -58,6 +58,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::Stat.register({
   :id         => :HP,
   :id_number  => 0,

Data/Scripts/011_Data/002_Hardcoded data/003_Nature.rb

@@ -27,6 +27,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::Nature.register({
   :id           => :HARDY,
   :id_number    => 0,

Data/Scripts/011_Data/002_Hardcoded data/004_GenderRatio.rb

@@ -29,6 +29,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::GenderRatio.register({
   :id            => :AlwaysMale,
   :name          => _INTL("Always Male")

Data/Scripts/011_Data/002_Hardcoded data/005_EggGroup.rb

@@ -23,6 +23,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::EggGroup.register({
   :id   => :Undiscovered,
   :name => _INTL("Undiscovered")

Data/Scripts/011_Data/002_Hardcoded data/006_BodyColor.rb

@@ -27,6 +27,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::BodyColor.register({
   :id        => :Red,
   :id_number => 0,

Data/Scripts/011_Data/002_Hardcoded data/007_Habitat.rb

@@ -23,6 +23,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::Habitat.register({
   :id   => :None,
   :name => _INTL("None")

Data/Scripts/011_Data/002_Hardcoded data/008_Status.rb

@@ -35,6 +35,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::Status.register({
   :id        => :NONE,
   :id_number => 0,

Data/Scripts/011_Data/002_Hardcoded data/009_Environment.rb

@@ -25,6 +25,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::Environment.register({
   :id   => :None,
   :name => _INTL("None")

Data/Scripts/011_Data/002_Hardcoded data/010_BattleWeather.rb

@@ -25,6 +25,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::BattleWeather.register({
   :id   => :None,
   :name => _INTL("None")

Data/Scripts/011_Data/002_Hardcoded data/011_BattleTerrain.rb

@@ -26,6 +26,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::BattleTerrain.register({
   :id   => :None,
   :name => _INTL("None")

Data/Scripts/011_Data/002_Hardcoded data/012_Target.rb

@@ -49,6 +49,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 # Bide, Counter, Metal Burst, Mirror Coat (calculate a target)
 GameData::Target.register({
   :id               => :None,

Data/Scripts/011_Data/002_Hardcoded data/015_Evolution.rb

@@ -0,0 +1,606 @@
+module GameData
+  class Evolution
+    attr_reader :id
+    attr_reader :real_name
+    attr_reader :parameter
+    attr_reader :minimum_level   # 0 means parameter is the minimum level
+    attr_reader :level_up_proc
+    attr_reader :use_item_proc
+    attr_reader :on_trade_proc
+    attr_reader :after_evolution_proc
+
+    DATA = {}
+
+    extend ClassMethodsSymbols
+    include InstanceMethods
+
+    def self.load; end
+    def self.save; end
+
+    def initialize(hash)
+      @id                   = hash[:id]
+      @real_name            = hash[:id].to_s       || "Unnamed"
+      @parameter            = hash[:parameter]
+      @minimum_level        = hash[:minimum_level] || 0
+      @level_up_proc        = hash[:level_up_proc]
+      @use_item_proc        = hash[:use_item_proc]
+      @on_trade_proc        = hash[:on_trade_proc]
+      @after_evolution_proc = hash[:after_evolution_proc]
+    end
+
+    def call_level_up(*args)
+      return (@level_up_proc) ? @level_up_proc.call(*args) : nil
+    end
+
+    def call_use_item(*args)
+      return (@use_item_proc) ? @use_item_proc.call(*args) : nil
+    end
+
+    def call_on_trade(*args)
+      return (@on_trade_proc) ? @on_trade_proc.call(*args) : nil
+    end
+
+    def call_after_evolution(*args)
+      @after_evolution_proc.call(*args) if @after_evolution_proc
+    end
+  end
+end
+
+#===============================================================================
+
+GameData::Evolution.register({
+  :id => :None
+})
+
+GameData::Evolution.register({
+  :id            => :Level,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelMale,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && pkmn.male?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelFemale,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && pkmn.female?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelDay,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && PBDayNight.isDay?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelNight,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && PBDayNight.isNight?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelMorning,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && PBDayNight.isMorning?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelAfternoon,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && PBDayNight.isAfternoon?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelEvening,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && PBDayNight.isEvening?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelNoWeather,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.level >= parameter && $game_screen
+      next $game_screen.weather_type == PBFieldWeather::None
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelSun,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.level >= parameter && $game_screen
+      next $game_screen.weather_type == PBFieldWeather::Sun
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelRain,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.level >= parameter && $game_screen
+      next [PBFieldWeather::Rain, PBFieldWeather::HeavyRain,
+            PBFieldWeather::Storm].include?($game_screen.weather_type)
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelSnow,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.level >= parameter && $game_screen
+      next [PBFieldWeather::Snow, PBFieldWeather::Blizzard].include?($game_screen.weather_type)
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelSandstorm,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.level >= parameter && $game_screen
+      next $game_screen.weather_type == PBFieldWeather::Sandstorm
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelCycling,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.bicycle
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelSurfing,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.surfing
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelDiving,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.diving
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelDarkness,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
+    next pkmn.level >= parameter && map_metadata && map_metadata.dark_map
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :LevelDarkInParty,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next $Trainer.has_pokemon_of_type?(:DARK) if pkmn.level >= parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :AttackGreater,   # Hitmonlee
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && pkmn.attack > pkmn.defense
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :AtkDefEqual,   # Hitmontop
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && pkmn.attack == pkmn.defense
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :DefenseGreater,   # Hitmonchan
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && pkmn.attack < pkmn.defense
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Silcoon,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && (((pkmn.personalID >> 16) & 0xFFFF) % 10) < 5
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Cascoon,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter && (((pkmn.personalID >> 16) & 0xFFFF) % 10) >= 5
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Ninjask,
+  :parameter     => Integer,
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.level >= parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :Shedinja,
+  :parameter            => Integer,
+  :level_up_proc        => proc { |pkmn, parameter|
+    next false   # This is a dummy proc and shouldn't next true
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if $Trainer.party_full?
+    next false if !$PokemonBag.pbHasItem?(:POKEBALL)
+    PokemonEvolutionScene.pbDuplicatePokemon(pkmn, new_species)
+    $PokemonBag.pbDeleteItem(:POKEBALL)
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Happiness,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessMale,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220 && pkmn.male?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessFemale,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220 && pkmn.female?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessDay,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220 && PBDayNight.isDay?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessNight,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220 && PBDayNight.isNight?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessMove,
+  :parameter     => :Move,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.happiness >= 220
+      next pkmn.moves.any? { |m| m && m.id == parameter }
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HappinessMoveType,
+  :parameter     => :Type,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    if pkmn.happiness >= 220
+      next pkmn.moves.any? { |m| m && m.id > 0 && m.type == parameter }
+    end
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :HappinessHoldItem,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && pkmn.happiness >= 220
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :MaxHappiness,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.happiness == 255
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Beauty,   # Feebas
+  :parameter     => Integer,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.beauty >= parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :HoldItem,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :HoldItemMale,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && pkmn.male?
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :HoldItemFemale,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && pkmn.female?
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :DayHoldItem,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && PBDayNight.isDay?
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :NightHoldItem,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && PBDayNight.isNight?
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :HoldItemHappiness,
+  :parameter            => :Item,
+  :minimum_level        => 1,   # Needs any level up
+  :level_up_proc        => proc { |pkmn, parameter|
+    next pkmn.item == parameter && pkmn.happiness >= 220
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HasMove,
+  :parameter     => :Move,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.moves.any? { |m| m && m.id == parameter }
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HasMoveType,
+  :parameter     => :Type,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next pkmn.moves.any? { |m| m && m.type == parameter }
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :HasInParty,
+  :parameter     => :Species,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next $Trainer.has_species?(parameter)
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Location,
+  :parameter     => Integer,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    next $game_map.map_id == parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :Region,
+  :parameter     => Integer,
+  :minimum_level => 1,   # Needs any level up
+  :level_up_proc => proc { |pkmn, parameter|
+    map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
+    next map_metadata && map_metadata.town_map_position &&
+         map_metadata.town_map_position[0] == parameter
+  }
+})
+
+#===============================================================================
+# Evolution methods that trigger when using an item on the Pokémon
+#===============================================================================
+GameData::Evolution.register({
+  :id            => :Item,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :ItemMale,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter && pkmn.male?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :ItemFemale,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter && pkmn.female?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :ItemDay,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter && PBDayNight.isDay?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :ItemNight,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter && PBDayNight.isNight?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :ItemHappiness,
+  :parameter     => :Item,
+  :use_item_proc => proc { |pkmn, parameter, item|
+    next item == parameter && pkmn.happiness >= 220
+  }
+})
+
+#===============================================================================
+# Evolution methods that trigger when the Pokémon is obtained in a trade
+#===============================================================================
+GameData::Evolution.register({
+  :id            => :Trade,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :TradeMale,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next pkmn.male?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :TradeFemale,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next pkmn.female?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :TradeDay,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next PBDayNight.isDay?
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :TradeNight,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next PBDayNight.isNight?
+  }
+})
+
+GameData::Evolution.register({
+  :id                   => :TradeItem,
+  :parameter            => :Item,
+  :on_trade_proc        => proc { |pkmn, parameter, other_pkmn|
+    next pkmn.item == parameter
+  },
+  :after_evolution_proc => proc { |pkmn, new_species, parameter, evo_species|
+    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
+    pkmn.item = nil   # Item is now consumed
+    next true
+  }
+})
+
+GameData::Evolution.register({
+  :id            => :TradeSpecies,
+  :parameter     => :Species,
+  :on_trade_proc => proc { |pkmn, parameter, other_pkmn|
+    next pkmn.species == parameter && !other_pkmn.hasItem?(:EVERSTONE)
+  }
+})

Data/Scripts/011_Data/002_Hardcoded data/015_PBEvolution.rb

@@ -1,798 +0,0 @@
-module PBEvolution
-  # NOTE: If you're adding new evolution methods, don't skip any numbers.
-  #       Remember to update def self.maxValue just below the constants list.
-  None              = 0
-  Level             = 1
-  LevelMale         = 2
-  LevelFemale       = 3
-  LevelDay          = 4
-  LevelNight        = 5
-  LevelMorning      = 6
-  LevelAfternoon    = 7
-  LevelEvening      = 8
-  LevelNoWeather    = 9
-  LevelSun          = 10
-  LevelRain         = 11
-  LevelSnow         = 12
-  LevelSandstorm    = 13
-  LevelCycling      = 14
-  LevelSurfing      = 15
-  LevelDiving       = 16
-  LevelDarkness     = 17
-  LevelDarkInParty  = 18
-  AttackGreater     = 19
-  AtkDefEqual       = 20
-  DefenseGreater    = 21
-  Silcoon           = 22
-  Cascoon           = 23
-  Ninjask           = 24
-  Shedinja          = 25
-  Happiness         = 26
-  HappinessMale     = 27
-  HappinessFemale   = 28
-  HappinessDay      = 29
-  HappinessNight    = 30
-  HappinessMove     = 31
-  HappinessMoveType = 32
-  HappinessHoldItem = 33
-  MaxHappiness      = 34
-  Beauty            = 35
-  HoldItem          = 36
-  HoldItemMale      = 37
-  HoldItemFemale    = 38
-  DayHoldItem       = 39
-  NightHoldItem     = 40
-  HoldItemHappiness = 41
-  HasMove           = 42
-  HasMoveType       = 43
-  HasInParty        = 44
-  Location          = 45
-  Region            = 46
-  Item              = 47
-  ItemMale          = 48
-  ItemFemale        = 49
-  ItemDay           = 50
-  ItemNight         = 51
-  ItemHappiness     = 52
-  Trade             = 53
-  TradeMale         = 54
-  TradeFemale       = 55
-  TradeDay          = 56
-  TradeNight        = 57
-  TradeItem         = 58
-  TradeSpecies      = 59
-
-  def self.maxValue; return 59; end
-
-  @@evolution_methods = HandlerHash.new(:PBEvolution)
-
-  def self.copy(sym, *syms)
-    @@evolution_methods.copy(sym, *syms)
-  end
-
-  def self.register(sym, hash)
-    @@evolution_methods.add(sym, hash)
-  end
-
-  def self.registerIf(cond, hash)
-    @@evolution_methods.addIf(cond, hash)
-  end
-
-  def self.hasFunction?(method, function)
-    method = (method.is_a?(Numeric)) ? method : getConst(PBEvolution, method)
-    method_hash = @@evolution_methods[method]
-    return method_hash && method_hash.keys.include?(function)
-  end
-
-  def self.getFunction(method, function)
-    method = (method.is_a?(Numeric)) ? method : getConst(PBEvolution, method)
-    method_hash = @@evolution_methods[method]
-    return (method_hash && method_hash[function]) ? method_hash[function] : nil
-  end
-
-  def self.call(function, method, *args)
-    method = (method.is_a?(Numeric)) ? method : getConst(PBEvolution, method)
-    method_hash = @@evolution_methods[method]
-    return nil if !method_hash || !method_hash[function]
-    return method_hash[function].call(*args)
-  end
-end
-
-#===============================================================================
-# Evolution helper functions
-#===============================================================================
-module EvolutionHelper
-  module_function
-
-  def evolutions(species, ignore_none = false)
-    ret = []
-    evoData =  GameData::Species.get(species).evolutions
-    return ret if !evoData || evoData.length == 0
-    evoData.each do |evo|
-      next if evo[3]   # Is the prevolution
-      next if evo[1] == PBEvolution::None && ignore_none
-      ret.push([evo[1], evo[2], evo[0]])   # [Method, parameter, species]
-    end
-    return ret
-  end
-
-  def family_evolutions(species, ignore_none = true)
-    evos = self.evolutions(species, ignore_none)
-    return nil if evos.length == 0
-    evos.sort! { |a, b| GameData::Species.get(a[2]).id_number <=> GameData::Species.get(b[2]).id_number }
-    ret = []
-    for i in 0...evos.length
-      ret.push([species].concat(evos[i]))
-      evo_array = self.family_evolutions(evos[i][2])
-      ret.concat(evo_array) if evo_array && evo_array.length > 0
-    end
-    return ret
-  end
-
-  def all_related_species(species)
-    species = self.baby_species(species)
-    evos = self.family_evolutions(species, false)
-    return [species] if !evos || evos.length == 0
-    return [species].concat(evos.map { |e| e[3] }).uniq
-  end
-
-  def previous_species(species)
-    evoData =  GameData::Species.get(species).evolutions
-    return species if !evoData || evoData.length == 0
-    evoData.each do |evo|
-      return evo[0] if evo[3]   # Is the prevolution
-    end
-    return species
-  end
-
-  def baby_species(species, check_items = false, item1 = nil, item2 = nil)
-    ret = species
-    evoData =  GameData::Species.get(species).evolutions
-    return ret if !evoData || evoData.length == 0
-    evoData.each do |evo|
-      next if !evo[3]   # Not the prevolution
-      if check_items
-        incense = GameData::Species.get(evo[0]).incense
-        ret = evo[0] if !incense || item1 == incense || item2 == incense
-      else
-        ret = evo[0]   # Species of prevolution
-      end
-      break
-    end
-    ret = self.baby_species(ret, item1, item2) if ret != species
-    return ret
-  end
-
-  def minimum_level(species)
-    evoData =  GameData::Species.get(species).evolutions
-    return 1 if !evoData || evoData.length == 0
-    ret = -1
-    evoData.each do |evo|
-      next if !evo[3]   # Is the prevolution
-      if PBEvolution.hasFunction?(evo[1], "levelUpCheck")
-        min_level = PBEvolution.getFunction(evo[1], "minimumLevel")
-        ret = evo[2] if !min_level || min_level != 1
-      end
-      break   # Because only one prevolution method can be defined
-    end
-    return (ret == -1) ? 1 : ret
-  end
-
-  def check_family_for_method(species, method, param = nil)
-    species = self.baby_species(species)
-    evos = self.family_evolutions(species)
-    return false if !evos || evos.length == 0
-    for evo in evos
-      if method.is_a?(Array)
-        next if !method.include?(evo[1])
-      elsif method >= 0
-        next if evo[1] != method
-      end
-      next if param && evo[2] != param
-      return true
-    end
-    return false
-  end
-
-  # Used by the Moon Ball when checking if a Pokémon's evolution family includes
-  # an evolution that uses the Moon Stone.
-  def check_family_for_method_item(species, param = nil)
-    species = self.baby_species(species)
-    evos = self.family_evolutions(species)
-    return false if !evos || evos.length == 0
-    for evo in evos
-      next if !PBEvolution.hasFunction?(evo[1], "itemCheck")
-      next if param && evo[2] != param
-      return true
-    end
-    return false
-  end
-end
-
-
-
-# @deprecated Use {EvolutionHelper#evolutions} instead. This alias is slated to be removed in v20.
-def pbGetEvolvedFormData(species, ignore_none = false)
-  Deprecation.warn_method('pbGetEvolvedFormData', 'v20', 'EvolutionHelper.evolutions(species)')
-  return EvolutionHelper.evolutions(species, ignore_none)
-end
-
-# @deprecated Use {EvolutionHelper#family_evolutions} instead. This alias is slated to be removed in v20.
-def pbGetEvolutionFamilyData(species)   # Unused
-  Deprecation.warn_method('pbGetEvolutionFamilyData', 'v20', 'EvolutionHelper.family_evolutions(species)')
-  return EvolutionHelper.family_evolutions(species, ignore_none)
-end
-
-# @deprecated Use {EvolutionHelper#previous_species} instead. This alias is slated to be removed in v20.
-def pbGetPreviousForm(species)   # Unused
-  Deprecation.warn_method('pbGetPreviousForm', 'v20', 'EvolutionHelper.previous_species(species)')
-  return EvolutionHelper.previous_species(species)
-end
-
-# @deprecated Use {EvolutionHelper#baby_species} instead. This alias is slated to be removed in v20.
-def pbGetBabySpecies(species, check_items = false, item1 = nil, item2 = nil)
-  Deprecation.warn_method('pbGetBabySpecies', 'v20', 'EvolutionHelper.baby_species(species)')
-  return EvolutionHelper.baby_species(species, check_items, item1, item2)
-end
-
-# @deprecated Use {EvolutionHelper#minimum_level} instead. This alias is slated to be removed in v20.
-def pbGetMinimumLevel(species)
-  Deprecation.warn_method('pbGetMinimumLevel', 'v20', 'EvolutionHelper.minimum_level(species)')
-  return EvolutionHelper.minimum_level(species)
-end
-
-# @deprecated Use {EvolutionHelper#check_family_for_method} instead. This alias is slated to be removed in v20.
-def pbCheckEvolutionFamilyForMethod(species, method, param = nil)
-  Deprecation.warn_method('pbCheckEvolutionFamilyForMethod', 'v20', 'EvolutionHelper.check_family_for_method(species, method)')
-  return EvolutionHelper.check_family_for_method(species, method, param)
-end
-
-# @deprecated Use {EvolutionHelper#check_family_for_method_item} instead. This alias is slated to be removed in v20.
-def pbCheckEvolutionFamilyForItemMethodItem(species, param = nil)
-  Deprecation.warn_method('pbCheckEvolutionFamilyForItemMethodItem', 'v20', 'EvolutionHelper.check_family_for_method_item(species, item)')
-  return EvolutionHelper.check_family_for_method_item(species, param)
-end
-
-#===============================================================================
-# Evolution checks
-#===============================================================================
-module EvolutionCheck
-  module_function
-
-  # Checks whether a Pokemon can evolve because of levelling up.
-  # @param pkmn [Pokemon] the Pokémon trying to evolve
-  def check_level_up_methods(pkmn)
-    return check_ex(pkmn) { |pkmn, method, parameter, new_species|
-      success = PBEvolution.call("levelUpCheck", method, pkmn, parameter)
-      next (success) ? new_species : nil
-    }
-  end
-
-  # Checks whether a Pokemon can evolve because of using an item on it.
-  # @param pkmn [Pokemon] the Pokémon trying to evolve
-  # @param item [Symbol, GameData::Item, nil] the item being used
-  def check_item_methods(pkmn, item)
-    return check_ex(pkmn) { |pkmn, method, parameter, new_species|
-      success = PBEvolution.call("itemCheck", method, pkmn, parameter, item)
-      return (success) ? new_species : nil
-    }
-  end
-
-  # Checks whether a Pokemon can evolve because of being traded.
-  # @param pkmn [Pokemon] the Pokémon trying to evolve
-  # @param other_pkmn [Pokemon] the other Pokémon involved in the trade
-  def check_trade_methods(pkmn, other_pkmn)
-    return check_ex(pkmn) { |pkmn, method, parameter, new_species|
-      success = PBEvolution.call("tradeCheck", method, pkmn, parameter, other_pkmn)
-      next (success) ? new_species : nil
-    }
-  end
-
-  # Called after a Pokémon evolves, to remove its held item (if the evolution
-  # required it to have a held item) or duplicate the Pokémon (Shedinja only).
-  # @param pkmn [Pokemon] the Pokémon trying to evolve
-  # @param evolved_species [Pokemon] the species that the Pokémon evolved into
-  def check_after_evolution(pkmn, evolved_species)
-    pkmn.species_data.evolutions.each do |evo|   # [new_species, method, parameter, boolean]
-      next if evo[3]   # Prevolution
-      break if PBEvolution.call("afterEvolution", evo[1], pkmn, evo[0], evo[2], evolved_species)
-    end
-  end
-
-  private
-
-  # The core method that performs evolution checks. Needs a block given to it,
-  # which will provide either a GameData::Species ID (the species to evolve
-  # into) or nil (keep checking).
-  # @param pkmn [Pokemon] the Pokémon trying to evolve
-  def self.check_ex(pkmn)
-    return nil if !pkmn.species || pkmn.egg? || pkmn.shadowPokemon?
-    return nil if pkmn.hasItem?(:EVERSTONE)
-    return nil if pkmn.hasAbility?(:BATTLEBOND)
-    ret = nil
-    pkmn.species_data.evolutions.each do |evo|   # [new_species, method, parameter, boolean]
-      next if evo[3]   # Prevolution
-      ret = yield pkmn, evo[1], evo[2], evo[0]   # pkmn, method, parameter, new_species
-      break if ret
-    end
-    return ret
-  end
-end
-
-#===============================================================================
-# Evolution methods that trigger when levelling up
-#===============================================================================
-PBEvolution.register(:Level, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter
-  }
-})
-
-PBEvolution.register(:LevelMale, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && pkmn.male?
-  }
-})
-
-PBEvolution.register(:LevelFemale, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && pkmn.female?
-  }
-})
-
-PBEvolution.register(:LevelDay, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && PBDayNight.isDay?
-  }
-})
-
-PBEvolution.register(:LevelNight, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && PBDayNight.isNight?
-  }
-})
-
-PBEvolution.register(:LevelMorning, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && PBDayNight.isMorning?
-  }
-})
-
-PBEvolution.register(:LevelAfternoon, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && PBDayNight.isAfternoon?
-  }
-})
-
-PBEvolution.register(:LevelEvening, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && PBDayNight.isEvening?
-  }
-})
-
-PBEvolution.register(:LevelNoWeather, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter && $game_screen
-      next $game_screen.weather_type == PBFieldWeather::None
-    end
-  }
-})
-
-PBEvolution.register(:LevelSun, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter && $game_screen
-      next $game_screen.weather_type == PBFieldWeather::Sun
-    end
-  }
-})
-
-PBEvolution.register(:LevelRain, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter && $game_screen
-      next [PBFieldWeather::Rain, PBFieldWeather::HeavyRain,
-            PBFieldWeather::Storm].include?($game_screen.weather_type)
-    end
-  }
-})
-
-PBEvolution.register(:LevelSnow, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter && $game_screen
-      next [PBFieldWeather::Snow, PBFieldWeather::Blizzard].include?($game_screen.weather_type)
-    end
-  }
-})
-
-PBEvolution.register(:LevelSandstorm, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter && $game_screen
-      next $game_screen.weather_type == PBFieldWeather::Sandstorm
-    end
-  }
-})
-
-PBEvolution.register(:LevelCycling, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.bicycle
-  }
-})
-
-PBEvolution.register(:LevelSurfing, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.surfing
-  }
-})
-
-PBEvolution.register(:LevelDiving, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && $PokemonGlobal && $PokemonGlobal.diving
-  }
-})
-
-PBEvolution.register(:LevelDarkness, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
-    next pkmn.level >= parameter && map_metadata && map_metadata.dark_map
-  }
-})
-
-PBEvolution.register(:LevelDarkInParty, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next $Trainer.has_pokemon_of_type?(:DARK) if pkmn.level >= parameter
-  }
-})
-
-PBEvolution.register(:AttackGreater, {    # Hitmonlee
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && pkmn.attack > pkmn.defense
-  }
-})
-
-PBEvolution.register(:AtkDefEqual, {    # Hitmontop
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && pkmn.attack == pkmn.defense
-  }
-})
-
-PBEvolution.register(:DefenseGreater, {    # Hitmonchan
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && pkmn.attack < pkmn.defense
-  }
-})
-
-PBEvolution.register(:Silcoon, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && (((pkmn.personalID >> 16) & 0xFFFF) % 10) < 5
-  }
-})
-
-PBEvolution.register(:Cascoon, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter && (((pkmn.personalID >> 16) & 0xFFFF) % 10) >= 5
-  }
-})
-
-PBEvolution.register(:Ninjask, {
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.level >= parameter
-  }
-})
-
-PBEvolution.register(:Shedinja, {
-  "parameterType"  => nil,
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if $Trainer.party_full?
-    next false if !$PokemonBag.pbHasItem?(:POKEBALL)
-    PokemonEvolutionScene.pbDuplicatePokemon(pkmn, new_species)
-    $PokemonBag.pbDeleteItem(:POKEBALL)
-    next true
-  }
-})
-
-PBEvolution.register(:Happiness, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness >= 220
-  }
-})
-
-PBEvolution.register(:HappinessMale, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness >= 220 && pkmn.male?
-  }
-})
-
-PBEvolution.register(:HappinessFemale, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness >= 220 && pkmn.female?
-  }
-})
-
-PBEvolution.register(:HappinessDay, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness >= 220 && PBDayNight.isDay?
-  }
-})
-
-PBEvolution.register(:HappinessNight, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness >= 220 && PBDayNight.isNight?
-  }
-})
-
-PBEvolution.register(:HappinessMove, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Move,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    if pkmn.happiness >= 220
-      next pkmn.moves.any? { |m| m && m.id == parameter }
-    end
-  }
-})
-
-PBEvolution.register(:HappinessMoveType, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Type,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    if pkmn.happiness >= 220
-      next pkmn.moves.any? { |m| m && m.id > 0 && m.type == parameter }
-    end
-  }
-})
-
-PBEvolution.register(:HappinessHoldItem, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && pkmn.happiness >= 220
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:MaxHappiness, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => nil,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.happiness == 255
-  }
-})
-
-PBEvolution.register(:Beauty, {   # Feebas
-  "minimumLevel" => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next pkmn.beauty >= parameter
-  }
-})
-
-PBEvolution.register(:HoldItem, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:HoldItemMale, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && pkmn.male?
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:HoldItemFemale, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && pkmn.female?
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:DayHoldItem, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && PBDayNight.isDay?
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:NightHoldItem, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && PBDayNight.isNight?
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:HoldItemHappiness, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Item,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.item == parameter && pkmn.happiness >= 220
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:HasMove, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Move,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.moves.any? { |m| m && m.id == parameter }
-  }
-})
-
-PBEvolution.register(:HasMoveType, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Type,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next pkmn.moves.any? { |m| m && m.type == parameter }
-  }
-})
-
-PBEvolution.register(:HasInParty, {
-  "minimumLevel"  => 1,   # Needs any level up
-  "parameterType" => :Species,
-  "levelUpCheck"  => proc { |pkmn, parameter|
-    next $Trainer.has_species?(parameter)
-  }
-})
-
-PBEvolution.register(:Location, {
-  "minimumLevel" => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
-    next $game_map.map_id == parameter
-  }
-})
-
-PBEvolution.register(:Region, {
-  "minimumLevel" => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
-    map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
-    next map_metadata && map_metadata.town_map_position &&
-         map_metadata.town_map_position[0] == parameter
-  }
-})
-
-#===============================================================================
-# Evolution methods that trigger when using an item on the Pokémon
-#===============================================================================
-PBEvolution.register(:Item, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter
-  }
-})
-
-PBEvolution.register(:ItemMale, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter && pkmn.male?
-  }
-})
-
-PBEvolution.register(:ItemFemale, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter && pkmn.female?
-  }
-})
-
-PBEvolution.register(:ItemDay, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter && PBDayNight.isDay?
-  }
-})
-
-PBEvolution.register(:ItemNight, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter && PBDayNight.isNight?
-  }
-})
-
-PBEvolution.register(:ItemHappiness, {
-  "parameterType" => :Item,
-  "itemCheck"     => proc { |pkmn, parameter, item|
-    next item == parameter && pkmn.happiness >= 220
-  }
-})
-
-#===============================================================================
-# Evolution methods that trigger when the Pokémon is obtained in a trade
-#===============================================================================
-PBEvolution.register(:Trade, {
-  "parameterType" => nil,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next true
-  }
-})
-
-PBEvolution.register(:TradeMale, {
-  "parameterType" => nil,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next pkmn.male?
-  }
-})
-
-PBEvolution.register(:TradeFemale, {
-  "parameterType" => nil,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next pkmn.female?
-  }
-})
-
-PBEvolution.register(:TradeDay, {
-  "parameterType" => nil,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next PBDayNight.isDay?
-  }
-})
-
-PBEvolution.register(:TradeNight, {
-  "parameterType" => nil,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next PBDayNight.isNight?
-  }
-})
-
-PBEvolution.register(:TradeItem, {
-  "parameterType" => :Item,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next pkmn.item == parameter
-  },
-  "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
-    next false if evo_species != new_species || !pkmn.hasItem?(parameter)
-    pkmn.item = nil   # Item is now consumed
-    next true
-  }
-})
-
-PBEvolution.register(:TradeSpecies, {
-  "parameterType" => :Species,
-  "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|
-    next pkmn.species == parameter && !other_pkmn.hasItem?(:EVERSTONE)
-  }
-})

Data/Scripts/011_Data/002_Hardcoded data/016_EncounterType.rb

@@ -24,6 +24,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::EncounterType.register({
   :id             => :Land,
   :type           => :land,

Data/Scripts/011_Data/002_Hardcoded data/017_BodyShape.rb

@@ -30,6 +30,8 @@ module GameData
   end
 end
 
+#===============================================================================
+
 GameData::BodyShape.register({
   :id        => :Head,
   :id_number => 1,

Data/Scripts/012_Battle/008_BattleHandlers_Items.rb

@@ -861,8 +861,7 @@ BattleHandlers::DamageCalcTargetItem.add(:EVIOLITE,
     #       means it also cares about the Pokémon's form. Some forms cannot
     #       evolve even if the species generally can, and such forms are not
     #       affected by Eviolite.
-    evos = target.pokemon.species_data.evolutions
+    if target.pokemon.species_data.get_evolutions(true).length > 0
-    if evos.any? { |e| e[1] != PBEvolution::None && !e[3] }   # Not a "None", not a prevolution
       mults[:defense_multiplier] *= 1.5
     end
   }

Data/Scripts/012_Battle/009_PokeBall_CatchEffects.rb

@@ -200,7 +200,7 @@ BallHandlers::ModifyCatchRate.add(:MOONBALL,proc { |ball,catchRate,battle,battle
   #       family can evolve with the Moon Stone, not whether the target itself
   #       can immediately evolve with the Moon Stone.
   moon_stone = GameData::Item.try_get(:MOONSTONE)
-  if moon_stone && EvolutionHelper.check_family_for_method_item(battler.species, moon_stone.id)
+  if moon_stone && battler.pokemon.species_data.family_item_evolutions_use_item?(moon_stone.id)
     catchRate *= 4
   end
   next [catchRate, 255].min

Data/Scripts/013_Overworld/006_PField_Battles.rb

@@ -596,7 +596,7 @@ def pbEvolutionCheck(currentLevels)
     pkmn = $Trainer.party[i]
     next if !pkmn || (pkmn.hp==0 && !Settings::CHECK_EVOLUTION_FOR_FAINTED_POKEMON)
     next if currentLevels[i] && pkmn.level==currentLevels[i]
-    newSpecies = EvolutionCheck.check_level_up_methods(pkmn)
+    newSpecies = pkmn.check_evolution_on_level_up
     next if !newSpecies
     evo = PokemonEvolutionScene.new
     evo.pbStartScreen(pkmn,newSpecies)

Data/Scripts/013_Overworld/013_PField_DayCare.rb

@@ -172,7 +172,7 @@ def pbDayCareGenerateEgg
     babyspecies = (ditto1) ? father.species : mother.species
   end
   # Determine the egg's species
-  babyspecies = EvolutionHelper.baby_species(babyspecies, true, mother.item_id, father.item_id)
+  babyspecies = GameData::Species.get(babyspecies).get_bably_species(true, mother.item_id, father.item_id)
   case babyspecies
   when :MANAPHY
     babyspecies = :PHIONE if GameData::Species.exists?(:PHIONE)
@@ -201,7 +201,7 @@ def pbDayCareGenerateEgg
   if [:RATTATA, :SANDSHREW, :VULPIX, :DIGLETT, :MEOWTH, :GEODUDE, :GRIMER].include?(babyspecies)
     if mother.form==1
       egg.form = 1 if mother.hasItem?(:EVERSTONE)
-    elsif EvolutionHelper.baby_species(father.species, true, mother.item_id, father.item_id) == babyspecies
+    elsif father.species_data.get_baby_species(true, mother.item_id, father.item_id) == babyspecies
       egg.form = 1 if father.form==1 && father.hasItem?(:EVERSTONE)
     end
   end

Data/Scripts/015_Items/001_PItem_Items.rb

@@ -175,7 +175,7 @@ def pbChangeLevel(pkmn,newlevel,scene)
       pbLearnMove(pkmn,i[1],true) { scene.pbUpdate }
     end
     # Check for evolution
-    newspecies = EvolutionCheck.check_level_up_methods(pkmn)
+    newspecies = pkmn.check_evolution_on_level_up
     if newspecies
       pbFadeOutInWithMusic {
         evo = PokemonEvolutionScene.new
@@ -476,7 +476,7 @@ def pbUseItem(bag,item,bagscene=nil)
     if itm.is_evolution_stone?
       annot = []
       for pkmn in $Trainer.party
-        elig = EvolutionCheck.check_item_methods(pkmn, item)
+        elig = pkmn.check_evolution_on_use_item(item)
         annot.push((elig) ? _INTL("ABLE") : _INTL("NOT ABLE"))
       end
     end

Data/Scripts/015_Items/002_PItem_ItemEffects.rb

@@ -348,7 +348,7 @@ ItemHandlers::UseOnPokemon.addIf(proc { |item| GameData::Item.get(item).is_evolu
       scene.pbDisplay(_INTL("It won't have any effect."))
       next false
     end
-    newspecies = EvolutionCheck.check_item_methods(pkmn, item)
+    newspecies = pkmn.check_evolution_on_use_item(item)
     if newspecies
       pbFadeOutInWithMusic {
         evo = PokemonEvolutionScene.new
@@ -356,7 +356,7 @@ ItemHandlers::UseOnPokemon.addIf(proc { |item| GameData::Item.get(item).is_evolu
         evo.pbEvolution(false)
         evo.pbEndScreen
         if scene.is_a?(PokemonPartyScreen)
-          scene.pbRefreshAnnotations(proc { |p| !EvolutionCheck.check_item_methods(p, item).nil? })
+          scene.pbRefreshAnnotations(proc { |p| !p.check_evolution_on_use_item(item).nil? })
           scene.pbRefresh
         end
       }

Data/Scripts/016_Pokemon/001_Pokemon.rb

@@ -893,6 +893,64 @@ class Pokemon
     @happiness = (@happiness + gain).clamp(0, 255)
   end
 
+  #=============================================================================
+  # Evolution checks
+  #=============================================================================
+  # Checks whether this Pokemon can evolve because of levelling up.
+  # @return [Symbol, nil] the ID of the species to evolve into
+  def check_evolution_on_level_up
+    return check_evolution_internal { |pkmn, new_species, method, parameter|
+      success = GameData::Evolution.get(method).call_level_up(pkmn, parameter)
+      next (success) ? new_species : nil
+    }
+  end
+
+  # Checks whether this Pokemon can evolve because of using an item on it.
+  # @param item_used [Symbol, GameData::Item, nil] the item being used
+  # @return [Symbol, nil] the ID of the species to evolve into
+  def check_evolution_on_use_item(item_used)
+    return check_evolution_internal { |pkmn, new_species, method, parameter|
+      success = GameData::Evolution.get(method).call_use_item(pkmn, parameter, item_used)
+      next (success) ? new_species : nil
+    }
+  end
+
+  # Checks whether this Pokemon can evolve because of being traded.
+  # @param other_pkmn [Pokemon] the other Pokémon involved in the trade
+  # @return [Symbol, nil] the ID of the species to evolve into
+  def check_evolution_on_trade(other_pkmn)
+    return check_evolution_internal { |pkmn, new_species, method, parameter|
+      success = GameData::Evolution.get(method).call_on_trade(pkmn, parameter, other_pkmn)
+      next (success) ? new_species : nil
+    }
+  end
+
+  # Called after this Pokémon evolves, to remove its held item (if the evolution
+  # required it to have a held item) or duplicate this Pokémon (Shedinja only).
+  # @param new_species [Pokemon] the species that this Pokémon evolved into
+  def action_after_evolution(new_species)
+    species_data.get_evolutions(true).each do |evo|   # [new_species, method, parameter, boolean]
+      next if evo[3]   # Prevolution
+      break if GameData::Evolution.get(method).call_after_evolution(self, evo[0], evo[2], new_species)
+    end
+  end
+
+  # The core method that performs evolution checks. Needs a block given to it,
+  # which will provide either a GameData::Species ID (the species to evolve
+  # into) or nil (keep checking).
+  # @return [Symbol, nil] the ID of the species to evolve into
+  def check_evolution_internal
+    return nil if egg? || shadowPokemon?
+    return nil if hasItem?(:EVERSTONE)
+    return nil if hasAbility?(:BATTLEBOND)
+    species_data.get_evolutions(true).each do |evo|   # [new_species, method, parameter, boolean]
+      next if evo[3]   # Prevolution
+      ret = yield self, evo[0], evo[1], evo[2]   # pkmn, new_species, method, parameter
+      return ret if ret
+    end
+    return nil
+  end
+
   #=============================================================================
   # Stat calculations
   #=============================================================================

Data/Scripts/017_UI/021_PScreen_Evolution.rb

@@ -600,7 +600,7 @@ class PokemonEvolutionScene
   end
 
   def pbEvolutionMethodAfterEvolution
-    EvolutionCheck.check_after_evolution(@pokemon, @newspecies)
+    @pokemon.action_after_evolution(@newspecies)
   end
 
   def self.pbDuplicatePokemon(pkmn, new_species)

Data/Scripts/017_UI/022_PScreen_Trading.rb

@@ -173,7 +173,7 @@ class PokemonTrade_Scene
     pbFadeOutAndHide(@sprites)
     pbDisposeSpriteHash(@sprites)
     @viewport.dispose
-    newspecies = EvolutionCheck.check_trade_methods(@pokemon2,@pokemon)
+    newspecies = @pokemon2.check_evolution_on_trade(@pokemon)
     if newspecies
       evo = PokemonEvolutionScene.new
       evo.pbStartScreen(@pokemon2,newspecies)

Data/Scripts/019_Other battles/004_PBattle_OrgBattleRules.rb

@@ -553,7 +553,7 @@ $canEvolve       = {}
 class BabyRestriction
   def isValid?(pokemon)
     baby=$babySpeciesData[pokemon.species] ? $babySpeciesData[pokemon.species] :
-       ($babySpeciesData[pokemon.species]=EvolutionHelper.baby_species(pokemon.species))
+       ($babySpeciesData[pokemon.species] = pokemon.species_data.get_baby_species)
     return baby==pokemon.species
   end
 end
@@ -563,10 +563,10 @@ end
 class UnevolvedFormRestriction
   def isValid?(pokemon)
     baby=$babySpeciesData[pokemon.species] ? $babySpeciesData[pokemon.species] :
-       ($babySpeciesData[pokemon.species]=EvolutionHelper.baby_species(pokemon.species))
+       ($babySpeciesData[pokemon.species] = pokemon.species_data.get_baby_species)
-    return false if baby!=pokemon.species
+    return false if pokemon.species != baby
     canEvolve=($canEvolve[pokemon.species]!=nil) ? $canEvolve[pokemon.species] :
-       ($canEvolve[pokemon.species]=(EvolutionHelper.evolutions(pokemon.species, true).length!=0))
+       ($canEvolve[pokemon.species] = pokemon.species_data.get_evolutions(true).length > 0))
     return false if !canEvolve
     return true
   end

Data/Scripts/019_Other battles/005_PBattle_OrgBattleGenerator.rb

@@ -103,17 +103,17 @@ def baseStatTotal(species)
 end
 
 def babySpecies(species)
-  $babySpecies[species] = EvolutionHelper.baby_species(species) if !$babySpecies[species]
+  $babySpecies[species] = GameData::Species.get(species).get_baby_species if !$babySpecies[species]
   return $babySpecies[species]
 end
 
 def minimumLevel(move)
-  $minimumLevel[species] = EvolutionHelper.minimum_level(species) if !$minimumLevel[species]
+  $minimumLevel[species] = GameData::Species.get(species).minimum_level if !$minimumLevel[species]
   return $minimumLevel[species]
 end
 
 def evolutions(species)
-  $evolutions[species] = EvolutionHelper.evolutions(species, true) if !$evolutions[species]
+  $evolutions[species] = GameData::Species.get(species).get_evolutions(true) if !$evolutions[species]
   return $evolutions[species]
 end
 

Data/Scripts/020_System and utilities/004_PSystem_PokemonUtilities.rb

@@ -292,15 +292,14 @@ def pbHasEgg?(species)
   return false if !species_data
   species = species_data.species
   # species may be unbreedable, so check its evolution's compatibilities
-  evoSpecies = EvolutionHelper.evolutions(species, true)
+  evoSpecies = species_data.get_evolutions(true)
-  compatSpecies = (evoSpecies && evoSpecies[0]) ? evoSpecies[0][2] : species
+  compatSpecies = (evoSpecies && evoSpecies[0]) ? evoSpecies[0][0] : species
   species_data = GameData::Species.try_get(compatSpecies)
   compat = species_data.egg_groups
-  return false if compat.include?(:Undiscovered)
+  return false if compat.include?(:Undiscovered) || compat.include?(:Ditto)
-  return false if compat.include?(:Ditto)
+  baby = GameData::Species.get(species).get_baby_species
-  baby = EvolutionHelper.baby_species(species)
   return true if species == baby   # Is a basic species
-  baby = EvolutionHelper.baby_species(species, true)
+  baby = GameData::Species.get(species).get_baby_species(true)
   return true if species == baby   # Is an egg species without incense
   return false
 end

Data/Scripts/021_Debug/004_Editor_Screens.rb

@@ -1290,12 +1290,12 @@ def pbRegionalDexEditorMain
           GameData::Species.each { |s| new_dex.push(s.species) if s.form == 0 }
           dex_lists.push(new_dex)
           refresh_list = true
-        when 2   # Fill with National Dex
+        when 2   # Fill with National Dex (grouped families)
           new_dex = []
           seen = []
           GameData::Species.each do |s|
             next if s.form != 0 || seen.include?(s.species)
-            family = EvolutionHelper.all_related_species(s.species)
+            family = s.get_related_species
             new_dex.concat(family)
             seen.concat(family)
           end
@@ -1343,12 +1343,12 @@ def pbAppendEvoToFamilyArray(species, array, seenarray)
   return if seenarray[species]
   array.push(species)
   seenarray[species] = true
-  evos = EvolutionHelper.evolutions(species)
+  evos = GameData::Species.get(species).get_evolutions
   if evos.length > 0
-    evos.sort! { |a, b| a[2] <=> b[2] }
+    evos.sort! { |a, b| GameData::Species.get(a[0]).id_number <=> GameData::Species.get(b[0]).id_number }
     subarray = []
     for i in evos
-      pbAppendEvoToFamilyArray(i[2], subarray, seenarray)
+      pbAppendEvoToFamilyArray(i[0], subarray, seenarray)
     end
     array.push(subarray) if subarray.length > 0
   end
@@ -1359,7 +1359,7 @@ def pbGetEvoFamilies
   ret = []
   GameData::Species.each do |sp|
     next if sp.form > 0
-    species = EvolutionHelper.baby_species(sp.species)
+    species = sp.get_baby_species
     next if seen[species]
     subret = []
     pbAppendEvoToFamilyArray(species, subret, seen)

Data/Scripts/021_Debug/007_Editor_DataTypes.rb

@@ -1156,11 +1156,39 @@ end
 class EvolutionsProperty
   def initialize
     @methods = []
-    (PBEvolution.maxValue + 1).times do |i|
+    @evo_ids = []
-      @methods[i] = getConstantName(PBEvolution, i)
+    GameData::Evolution.each do |e|
+      @methods.push(e.real_name)
+      @evo_ids.push(e.id)
     end
   end
 
+  def edit_parameter(evo_method, value = nil)
+    param_type = GameData::Evolution.get(evo_method).parameter
+    return nil if param_type.nil?
+    ret = value
+    case param_type
+    when :Item
+      ret = pbChooseItemList(value)
+    when :Move
+      ret = pbChooseMoveList(value)
+    when :Species
+      ret = pbChooseSpeciesList(value)
+    when :Type
+      ret = pbChooseTypeList(value)
+    when :Ability
+      ret = pbChooseAbilityList(value)
+    else
+      params = ChooseNumberParams.new
+      params.setRange(0, 65535)
+      params.setDefaultValue(value) if value
+      params.setCancelValue(-1)
+      ret = pbMessageChooseNumber(_INTL("Choose a parameter."), params)
+      ret = nil if ret < 0
+    end
+    return ret
+  end
+
   def set(_settingname,oldsetting)
     ret = oldsetting
     cmdwin = pbListWindow([])
@@ -1182,20 +1210,18 @@ class EvolutionsProperty
             commands.push(_INTL("[ADD EVOLUTION]"))
           else
             level = realcmds[i][2]
-            param_type = PBEvolution.getFunction(realcmds[i][1], "parameterType")
+            evo_method_data = GameData::Evolution.get(realcmds[i][1])
-            has_param = !PBEvolution.hasFunction?(realcmds[i][1], "parameterType") || param_type != nil
+            param_type = evo_method_data.parameter
-            if has_param
+            if param_type.nil?
-              if param_type && !GameData.const_defined?(param_type.to_sym)
-                level = getConstantName(param_type, level)
-              else
-                level = level.to_s
-              end
-              level = "???" if !level || level.empty?
-              commands.push(_INTL("{1}: {2}, {3}",
-                 GameData::Species.get(realcmds[i][0]).name, @methods[realcmds[i][1]], level.to_s))
-            else
               commands.push(_INTL("{1}: {2}",
-                 GameData::Species.get(realcmds[i][0]).name, @methods[realcmds[i][1]]))
+                 GameData::Species.get(realcmds[i][0]).name, evo_method_data.real_name))
+            else
+              if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
+                level = getConstantName(param_type, level)
+              end
+              level = "???" if !level || (level.is_a?(String) && level.empty?)
+              commands.push(_INTL("{1}: {2}, {3}",
+                 GameData::Species.get(realcmds[i][0]).name, evo_method_data.real_name, level.to_s))
             end
           end
           cmd[1] = i if oldsel>=0 && realcmds[i][3]==oldsel
@@ -1221,42 +1247,19 @@ class EvolutionsProperty
             pbMessage(_INTL("Choose an evolved form, method and parameter."))
             newspecies = pbChooseSpeciesList
             if newspecies
-              newmethod = pbMessage(_INTL("Choose an evolution method."),@methods,-1)
+              newmethodindex = pbMessage(_INTL("Choose an evolution method."),@methods,-1)
-              if newmethod>0
+              if newmethodindex >= 0
-                newparam = -1
+                newmethod = @evo_ids[newmethodindex]
-                param_type = PBEvolution.getFunction(newmethod, "parameterType")
+                newparam = edit_parameter(newmethod)
-                has_param = !PBEvolution.hasFunction?(newmethod, "parameterType") || param_type != nil
+                if newparam || GameData::Evolution.get(newmethod).parameter.nil?
-                if has_param
+                  existing_evo = -1
-                  allow_zero = false
-                  case param_type
-                  when :Item
-                    newparam = pbChooseItemList
-                  when :Move
-                    newparam = pbChooseMoveList
-                  when :Species
-                    newparam = pbChooseSpeciesList
-                  when :Type
-                    newparam = pbChooseTypeList
-                  when :Ability
-                    newparam = pbChooseAbilityList
-                  else
-                    allow_zero = true
-                    params = ChooseNumberParams.new
-                    params.setRange(0,65535)
-                    params.setCancelValue(-1)
-                    newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
-                  end
-                end
-                if !has_param || newparam.is_a?(Symbol) ||
-                   (newparam.is_a?(Integer) && (newparam > 0 || (allow_zero && newparam == 0)))
-                  havemove = -1
                   for i in 0...realcmds.length
-                    havemove = realcmds[i][3] if realcmds[i][0]==newspecies &&
+                    existing_evo = realcmds[i][3] if realcmds[i][0]==newspecies &&
                                                      realcmds[i][1]==newmethod &&
                                                      realcmds[i][2]==newparam
                   end
-                  if havemove>=0
+                  if existing_evo >= 0
-                    oldsel = havemove
+                    oldsel = existing_evo
                   else
                     maxid = -1
                     realcmds.each { |i| maxid = [maxid,i[3]].max }
@@ -1274,16 +1277,16 @@ class EvolutionsProperty
             when 0   # Change species
               newspecies = pbChooseSpeciesList(entry[0])
               if newspecies
-                havemove = -1
+                existing_evo = -1
                 for i in 0...realcmds.length
-                  havemove = realcmds[i][3] if realcmds[i][0]==newspecies &&
+                  existing_evo = realcmds[i][3] if realcmds[i][0]==newspecies &&
                                                    realcmds[i][1]==entry[1] &&
                                                    realcmds[i][2]==entry[2]
                 end
-                if havemove>=0
+                if existing_evo >= 0
                   realcmds[cmd[1]] = nil
                   realcmds.compact!
-                  oldsel = havemove
+                  oldsel = existing_evo
                 else
                   entry[0] = newspecies
                   oldsel = entry[3]
@@ -1291,18 +1294,21 @@ class EvolutionsProperty
                 refreshlist = true
               end
             when 1   # Change method
-              newmethod = pbMessage(_INTL("Choose an evolution method."),@methods,-1,nil,entry[1])
+              default_index = 0
-              if newmethod>0
+              @evo_ids.each_with_index { |evo, i| default_index = i if evo == entry[1] }
-                havemove = -1
+              newmethodindex = pbMessage(_INTL("Choose an evolution method."),@methods,-1,nil,default_index)
+              if newmethodindex >= 0
+                newmethod = @evo_ids[newmethodindex]
+                existing_evo = -1
                 for i in 0...realcmds.length
-                  havemove = realcmds[i][3] if realcmds[i][0]==entry[0] &&
+                  existing_evo = realcmds[i][3] if realcmds[i][0]==entry[0] &&
                                                    realcmds[i][1]==newmethod &&
                                                    realcmds[i][2]==entry[2]
                 end
-                if havemove>=0
+                if existing_evo >= 0
                   realcmds[cmd[1]] = nil
                   realcmds.compact!
-                  oldsel = havemove
+                  oldsel = existing_evo
                 elsif newmethod != entry[1]
                   entry[1] = newmethod
                   entry[2] = 0
@@ -1311,50 +1317,27 @@ class EvolutionsProperty
                 refreshlist = true
               end
             when 2   # Change parameter
-              newparam = -1
+              if GameData::Evolution.get(entry[1]).parameter.nil?
-              param_type = PBEvolution.getFunction(entry[1], "parameterType")
+                pbMessage(_INTL("This evolution method doesn't use a parameter."))
-              has_param = !PBEvolution.hasFunction?(entry[1], "parameterType") || param_type != nil
-              if has_param
-                allow_zero = false
-                case param_type
-                when :Item
-                  newparam = pbChooseItemList(entry[2])
-                when :Move
-                  newparam = pbChooseMoveList(entry[2])
-                when :Species
-                  newparam = pbChooseSpeciesList(entry[2])
-                when :Type
-                  newparam = pbChooseTypeList(entry[2])
-                when :Ability
-                  newparam = pbChooseAbilityList(entry[2])
               else
-                  allow_zero = true
+                newparam = edit_parameter(entry[1], entry[2])
-                  params = ChooseNumberParams.new
+                if newparam
-                  params.setRange(0,65535)
+                  existing_evo = -1
-                  params.setDefaultValue(entry[2])
-                  params.setCancelValue(-1)
-                  newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
-                end
-                if newparam.is_a?(Symbol) ||
-                   (newparam.is_a?(Integer) && (newparam > 0 || (allow_zero && newparam == 0)))
-                  havemove = -1
                   for i in 0...realcmds.length
-                    havemove = realcmds[i][3] if realcmds[i][0]==entry[0] &&
+                    existing_evo = realcmds[i][3] if realcmds[i][0]==entry[0] &&
                                                      realcmds[i][1]==entry[1] &&
                                                      realcmds[i][2]==newparam
                   end
-                  if havemove>=0
+                  if existing_evo >= 0
                     realcmds[cmd[1]] = nil
                     realcmds.compact!
-                    oldsel = havemove
+                    oldsel = existing_evo
                   else
                     entry[2] = newparam
                     oldsel = entry[3]
                   end
                   refreshlist = true
                 end
-              else
-                pbMessage(_INTL("This evolution method doesn't use a parameter."))
               end
             when 3   # Delete
               realcmds[cmd[1]] = nil
@@ -1391,16 +1374,19 @@ class EvolutionsProperty
   def format(value)
     ret = ""
     for i in 0...value.length
-      ret << "," if i>0
+      ret << "," if i > 0
       param = value[i][2]
-      param_type = PBEvolution.getFunction(value[i][1], "parameterType")
+      evo_method_data = GameData::Evolution.get(value[i][1])
-      if param_type && !GameData.const_defined?(param_type.to_sym)
+      param_type = evo_method_data.parameter
+      if param_type.nil?
+        param = ""
+      elsif !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
         param = getConstantName(param_type, param)
       else
         param = param.to_s
       end
       param = "" if !param
-      ret << sprintf("#{GameData::Species.get(value[i][0]).name},#{@methods[value[i][1]]},#{param}")
+      ret << sprintf("#{GameData::Species.get(value[i][0]).name},#{evo_method_data.real_name},#{param}")
     end
     return ret
   end

Data/Scripts/021_Debug/009_Editor_Utilities.rb

@@ -4,7 +4,7 @@ def pbGetLegalMoves(species)
   return moves if !species_data
   species_data.moves.each { |m| moves.push(m[1]) }
   species_data.tutor_moves.each { |m| moves.push(m) }
-  babyspecies = EvolutionHelper.baby_species(species)
+  babyspecies = species_data.get_baby_species
   GameData::Species.get(babyspecies).egg_moves.each { |m| moves.push(m) }
   moves |= []   # Remove duplicates
   return moves

Data/Scripts/022_Compiler/002_Compiler_CompilePBS.rb

@@ -507,13 +507,13 @@ module Compiler
       pbSetWindowText(_INTL("Processing {1} evolution line {2}", FileLineData.file, species.id_number)) if species.id_number % 50 == 0
       species.evolutions.each do |evo|
         evo[0] = csvEnumField!(evo[0], :Species, "Evolutions", species.id_number)
-        param_type = PBEvolution.getFunction(evo[1], "parameterType")
+        param_type = GameData::Evolution.get(evo[1]).parameter
-        if param_type
+        if param_type.nil?
-          evo[2] = csvEnumField!(evo[2], param_type, "Evolutions", species.id_number)
-        elsif evo[2] && !evo[2].empty?
-          evo[2] = csvInt!(evo[2])
-        else
           evo[2] = nil
+        elsif param_type == Integer
+          evo[2] = csvPosInt!(evo[2])
+        else
+          evo[2] = csvEnumField!(evo[2], param_type, "Evolutions", species.id_number)
         end
       end
     end
@@ -621,14 +621,14 @@ module Compiler
           when "Evolutions"
             evo_array = []
             for i in 0...value.length / 3
-              param_type = PBEvolution.getFunction(value[i * 3 + 1], "parameterType")
+              param_type = GameData::Evolution.get(value[i * 3 + 1]).parameter
               param = value[i * 3 + 2]
-              if param_type
+              if param_type.nil?
-                param = csvEnumField!(param, param_type, "Evolutions", section_name)
-              elsif param && !param.empty?
-                param = csvInt!(param)
-              else
                 param = nil
+              elsif param_type == Integer
+                param = csvPosInt!(param)
+              else
+                param = csvEnumField!(param, param_type, "Evolutions", section_name)
               end
               evo_array.push([value[i * 3], value[i * 3 + 1], param, false])
             end

Data/Scripts/022_Compiler/003_Compiler_WritePBS.rb

@@ -331,20 +331,17 @@ module Compiler
             next if evo[3]   # Skip prevolution entries
             f.write(",") if need_comma
             need_comma = true
-            f.write(sprintf("%s,%s,", evo[0], getConstantName(PBEvolution, evo[1])))
+            evo_type_data = GameData::Evolution.get(evo[1])
-            param_type = PBEvolution.getFunction(evo[1], "parameterType")
+            param_type = evo_type_data.parameter
-            has_param = !PBEvolution.hasFunction?(evo[1], "parameterType") || param_type != nil
+            f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
-            next if !has_param
+            if !param_type.nil?
-            if param_type
+              if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
-              if GameData.const_defined?(param_type.to_sym)
-                f.write(evo[2].to_s)
-              else
                 f.write(getConstantName(param_type, evo[2]))
-              end
               else
                 f.write(evo[2].to_s)
               end
             end
+          end
           f.write("\r\n")
         end
         f.write(sprintf("Incense = %s\r\n", species.incense)) if species.incense
@@ -439,20 +436,17 @@ module Compiler
             next if evo[3]   # Skip prevolution entries
             f.write(",") if need_comma
             need_comma = true
-            f.write(sprintf("%s,%s,", evo[0], getConstantName(PBEvolution, evo[1])))
+            evo_type_data = GameData::Evolution.get(evo[1])
-            param_type = PBEvolution.getFunction(evo[1], "parameterType")
+            param_type = evo_type_data.parameter
-            has_param = !PBEvolution.hasFunction?(evo[1], "parameterType") || param_type != nil
+            f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
-            next if !has_param
+            if !param_type.nil?
-            if param_type
+              if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
-              if GameData.const_defined?(param_type.to_sym)
-                f.write(evo[2].to_s)
-              else
                 f.write(getConstantName(param_type, evo[2]))
-              end
               else
                 f.write(evo[2].to_s)
               end
             end
+          end
           f.write("\r\n")
         end
       end
@@ -496,7 +490,7 @@ module Compiler
           if current_family && current_family.include?(species)
             f.write(",") if comma
           else
-            current_family = EvolutionHelper.all_related_species(species)
+            current_family = GameData::Species.get(species).get_related_species
             comma = false
             f.write("\r\n")
           end

PBS/Gen 5/pokemon.txt

@@ -9805,7 +9805,7 @@ BattlerEnemyX = -1
 BattlerEnemyY = 29
 BattlerShadowX = 0
 BattlerShadowSize = 2
-Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,
+Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,20
 #-------------------------------
 [291]
 Name = Ninjask

PBS/Gen 7/pokemon.txt

@@ -9807,7 +9807,7 @@ BattlerEnemyX = -1
 BattlerEnemyY = 29
 BattlerShadowX = 0
 BattlerShadowSize = 2
-Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,
+Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,20
 #-------------------------------
 [291]
 Name = Ninjask

PBS/pokemon.txt

@@ -9807,7 +9807,7 @@ BattlerEnemyX = -1
 BattlerEnemyY = 29
 BattlerShadowX = 0
 BattlerShadowSize = 2
-Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,
+Evolutions = NINJASK,Ninjask,20,SHEDINJA,Shedinja,20
 #-------------------------------
 [291]
 Name = Ninjask