Tidied up evolution code and added lots more evolution methods

Data/Scripts/016_Pokemon/005_Pokemon_Evolution.rb

@@ -1,46 +1,68 @@
 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
-  Happiness         = 1
+  Level             = 1
-  HappinessDay      = 2
+  LevelMale         = 2
-  HappinessNight    = 3
+  LevelFemale       = 3
-  Level             = 4
+  LevelDay          = 4
-  Trade             = 5
+  LevelNight        = 5
-  TradeItem         = 6
+  LevelMorning      = 6
-  Item              = 7
+  LevelAfternoon    = 7
-  AttackGreater     = 8
+  LevelEvening      = 8
-  AtkDefEqual       = 9
+  LevelNoWeather    = 9
-  DefenseGreater    = 10
+  LevelSun          = 10
-  Silcoon           = 11
+  LevelRain         = 11
-  Cascoon           = 12
+  LevelSnow         = 12
-  Ninjask           = 13
+  LevelSandstorm    = 13
-  Shedinja          = 14
+  LevelCycling      = 14
-  Beauty            = 15
+  LevelSurfing      = 15
-  ItemMale          = 16
+  LevelDiving       = 16
-  ItemFemale        = 17
+  LevelDarkness     = 17
-  DayHoldItem       = 18
+  LevelDarkInParty  = 18
-  NightHoldItem     = 19
+  AttackGreater     = 19
-  HasMove           = 20
+  AtkDefEqual       = 20
-  HasInParty        = 21
+  DefenseGreater    = 21
-  LevelMale         = 22
+  Silcoon           = 22
-  LevelFemale       = 23
+  Cascoon           = 23
-  Location          = 24
+  Ninjask           = 24
-  TradeSpecies      = 25
+  Shedinja          = 25
-  LevelDay          = 26
+  Happiness         = 26
-  LevelNight        = 27
+  HappinessMale     = 27
-  LevelDarkInParty  = 28
+  HappinessFemale   = 28
-  LevelRain         = 29
+  HappinessDay      = 29
-  HappinessMoveType = 30
+  HappinessNight    = 30
-  LevelEvening      = 31
+  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
 
-  EVONAMES = ["None",
+  def self.maxValue; return 59; end
-     "Happiness",    "HappinessDay", "HappinessNight",   "Level",         "Trade",
-     "TradeItem",    "Item",         "AttackGreater",    "AtkDefEqual",   "DefenseGreater",
-     "Silcoon",      "Cascoon",      "Ninjask",          "Shedinja",      "Beauty",
-     "ItemMale",     "ItemFemale",   "DayHoldItem",      "NightHoldItem", "HasMove",
-     "HasInParty",   "LevelMale",    "LevelFemale",      "Location",      "TradeSpecies",
-     "LevelDay",     "LevelNight",   "LevelDarkInParty", "LevelRain",     "HappinessMoveType",
-     "LevelEvening"
-  ]
 
   @@evolution_methods = HandlerHash.new(:PBEvolution)
 
@@ -59,7 +81,7 @@ module PBEvolution
   def self.hasFunction?(method, function)
     method = (method.is_a?(Numeric)) ? method : getConst(PBEvolution, method)
     method_hash = @@evolution_methods[method]
-    return method_hash && method_hash[function]
+    return method_hash && method_hash.keys.include?(function)
   end
 
   def self.getFunction(method, function)
@@ -293,16 +315,36 @@ PBEvolution.register(:LevelNight, {
   }
 })
 
+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(:LevelDarkInParty, {
+PBEvolution.register(:LevelNoWeather, {
   "levelUpCheck" => proc { |pkmn, parameter|
-    if pkmn.level >= parameter
+    if pkmn.level >= parameter && $game_screen
-      next $Trainer.pokemonParty.any? { |p| p && p.hasType(:DARK) }
+      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
   }
 })
@@ -316,6 +358,54 @@ PBEvolution.register(:LevelRain, {
   }
 })
 
+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|
+    next pkmn.level >= parameter && pbGetMetadata($game_map.map_id, MetadataDarkMap)
+  }
+})
+
+PBEvolution.register(:LevelDarkInParty, {
+  "levelUpCheck" => proc { |pkmn, parameter|
+    if pkmn.level >= parameter
+      next $Trainer.pokemonParty.any? { |p| p && p.hasType(:DARK) }
+    end
+  }
+})
+
 PBEvolution.register(:AttackGreater, {    # Hitmonlee
   "levelUpCheck" => proc { |pkmn, parameter|
     next pkmn.level >= parameter && pkmn.attack > pkmn.defense
@@ -353,6 +443,7 @@ PBEvolution.register(:Ninjask, {
 })
 
 PBEvolution.register(:Shedinja, {
+  "parameterType"  => nil,
   "afterEvolution" => proc { |pkmn, new_species, parameter, evo_species|
     next false if $Trainer.party.length>=6
     next false if !$PokemonBag.pbHasItem?(getConst(PBItems,:POKEBALL))
@@ -363,23 +454,52 @@ PBEvolution.register(:Shedinja, {
 })
 
 PBEvolution.register(:Happiness, {
-  "minimumLevel" => 1,   # Needs any level up
+  "minimumLevel"  => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
+  "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
+  "minimumLevel"  => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
+  "parameterType" => nil,
+  "levelUpCheck"  => proc { |pkmn, parameter|
     next pkmn.happiness >= 220 && PBDayNight.isDay?
   }
 })
 
 PBEvolution.register(:HappinessNight, {
-  "minimumLevel" => 1,   # Needs any level up
+  "minimumLevel"  => 1,   # Needs any level up
-  "levelUpCheck" => proc { |pkmn, parameter|
+  "parameterType" => nil,
-    next pkmn.happiness >= 220 && PBDayNight.isDay?
+  "levelUpCheck"  => proc { |pkmn, parameter|
+    next pkmn.happiness >= 220 && PBDayNight.isNight?
+  }
+})
+
+PBEvolution.register(:HappinessMove, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBMoves,
+  "levelUpCheck"  => proc { |pkmn, parameter|
+    if pkmn.happiness >= 220
+      next pkmn.moves.any? { |m| m && m.id == parameter }
+    end
   }
 })
 
@@ -393,6 +513,27 @@ PBEvolution.register(:HappinessMoveType, {
   }
 })
 
+PBEvolution.register(:HappinessHoldItem, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBItems,
+  "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.setItem(0)   # 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|
@@ -400,6 +541,45 @@ PBEvolution.register(:Beauty, {   # Feebas
   }
 })
 
+PBEvolution.register(:HoldItem, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBItems,
+  "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.setItem(0)   # Item is now consumed
+    next true
+  }
+})
+
+PBEvolution.register(:HoldItemMale, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBItems,
+  "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.setItem(0)   # Item is now consumed
+    next true
+  }
+})
+
+PBEvolution.register(:HoldItemFemale, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBItems,
+  "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.setItem(0)   # Item is now consumed
+    next true
+  }
+})
+
 PBEvolution.register(:DayHoldItem, {
   "minimumLevel"  => 1,   # Needs any level up
   "parameterType" => :PBItems,
@@ -426,6 +606,19 @@ PBEvolution.register(:NightHoldItem, {
   }
 })
 
+PBEvolution.register(:HoldItemHappiness, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBItems,
+  "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.setItem(0)   # Item is now consumed
+    next true
+  }
+})
+
 PBEvolution.register(:HasMove, {
   "minimumLevel"  => 1,   # Needs any level up
   "parameterType" => :PBMoves,
@@ -434,6 +627,14 @@ PBEvolution.register(:HasMove, {
   }
 })
 
+PBEvolution.register(:HasMoveType, {
+  "minimumLevel"  => 1,   # Needs any level up
+  "parameterType" => :PBTypes,
+  "levelUpCheck"  => proc { |pkmn, parameter|
+    next pkmn.moves.any? { |m| m && m.type == parameter }
+  }
+})
+
 PBEvolution.register(:HasInParty, {
   "minimumLevel"  => 1,   # Needs any level up
   "parameterType" => :PBSpecies,
@@ -443,12 +644,20 @@ PBEvolution.register(:HasInParty, {
 })
 
 PBEvolution.register(:Location, {
-  "minimumLevel"  => 1,   # Needs any level up
+  "minimumLevel" => 1,   # Needs any level up
-  "levelUpCheck"  => proc { |pkmn, parameter|
+  "levelUpCheck" => proc { |pkmn, parameter|
     next $game_map.map_id == parameter
   }
 })
 
+PBEvolution.register(:Region, {
+  "minimumLevel" => 1,   # Needs any level up
+  "levelUpCheck" => proc { |pkmn, parameter|
+    mapPos = pbGetMetadata($game_map.map_id, MetadataMapPosition)
+    next mapPos && mapPos[0] == parameter
+  }
+})
+
 #===============================================================================
 # Evolution methods that trigger when using an item on the Pokémon
 #===============================================================================
@@ -473,15 +682,65 @@ PBEvolution.register(:ItemFemale, {
   }
 })
 
+PBEvolution.register(:ItemDay, {
+  "parameterType" => :PBItems,
+  "itemCheck"     => proc { |pkmn, parameter, item|
+    next item == parameter && PBDayNight.isDay?
+  }
+})
+
+PBEvolution.register(:ItemNight, {
+  "parameterType" => :PBItems,
+  "itemCheck"     => proc { |pkmn, parameter, item|
+    next item == parameter && PBDayNight.isNight?
+  }
+})
+
+PBEvolution.register(:ItemHappiness, {
+  "parameterType" => :PBItems,
+  "levelUpCheck"  => 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, {
-  "tradeCheck" => proc { |pkmn, parameter, other_pkmn|
+  "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" => :PBItems,
   "tradeCheck"    => proc { |pkmn, parameter, other_pkmn|

Data/Scripts/021_Debug/004_Editor_Screens.rb

@@ -811,7 +811,7 @@ def pbPokemonEditor
      [_INTL("BattlerAltitude"),ReadOnlyProperty,_INTL("Affects positioning of the Pokémon in battle. This is edited elsewhere.")],
      [_INTL("BattlerShadowX"),ReadOnlyProperty,_INTL("Affects positioning of the Pokémon in battle. This is edited elsewhere.")],
      [_INTL("BattlerShadowSize"),ReadOnlyProperty,_INTL("Affects positioning of the Pokémon in battle. This is edited elsewhere.")],
-     [_INTL("Evolutions"),EvolutionsProperty.new(PBEvolution::EVONAMES),_INTL("Evolution paths of this species.")],
+     [_INTL("Evolutions"),EvolutionsProperty.new,_INTL("Evolution paths of this species.")],
      [_INTL("Incense"),ItemProperty,_INTL("Item needed to be held by a parent to produce an egg of this species.")],
   ]
   pbListScreenBlock(_INTL("Pokémon species"),SpeciesLister.new(selection,false)) { |button,index|

Data/Scripts/021_Debug/006_Editor_DataTypes.rb

@@ -1182,8 +1182,11 @@ end
 
 
 class EvolutionsProperty
-  def initialize(methods)
+  def initialize
-    @methods = methods
+    @methods = []
+    (PBEvolution.maxValue + 1).times do |i|
+      @methods[i] = getConstantName(PBEvolution, i)
+    end
   end
 
   def set(_settingname,oldsetting)
@@ -1207,12 +1210,18 @@ class EvolutionsProperty
           else
             level = realcmds[i][1]
             param_type = PBEvolution.getFunction(realcmds[i][0], "parameterType")
-            if param_type
+            has_param = !PBEvolution.hasFunction?(realcmds[i][0], "parameterType") || param_type != nil
-              level = (Object.const_get(param_type).getName(level) rescue getConstantName(param_type, level) rescue level)
+            if has_param
+              if param_type
+                level = (Object.const_get(param_type).getName(level) rescue getConstantName(param_type, level) rescue level)
+              end
+              level = "???" if !level
+              commands.push(_INTL("{1}: {2}, {3}",
+                 PBSpecies.getName(realcmds[i][2]),@methods[realcmds[i][0]],level.to_s))
+            else
+              commands.push(_INTL("{1}: {2}",
+                 PBSpecies.getName(realcmds[i][2]),@methods[realcmds[i][0]]))
             end
-            level = "" if !level
-            commands.push(_INTL("{1}: {2}, {3}",
-               PBSpecies.getName(realcmds[i][2]),@methods[realcmds[i][0]],level.to_s))
           end
           cmd[1] = i if oldsel>=0 && realcmds[i][3]==oldsel
         end
@@ -1239,28 +1248,31 @@ class EvolutionsProperty
               newmethod = pbMessage(_INTL("Choose an evolution method."),@methods,-1)
               if newmethod>0
                 newparam = -1
-                allow_zero = false
                 param_type = PBEvolution.getFunction(newmethod, "parameterType")
-                case param_type
+                has_param = !PBEvolution.hasFunction?(newmethod, "parameterType") || param_type != nil
-                when :PBItems
+                if has_param
-                  newparam = pbChooseItemList
+                  allow_zero = false
-                when :PBMoves
+                  case param_type
-                  newparam = pbChooseMoveList
+                  when :PBItems
-                when :PBSpecies
+                    newparam = pbChooseItemList
-                  newparam = pbChooseSpeciesList
+                  when :PBMoves
-                when :PBTypes
+                    newparam = pbChooseMoveList
-                  allow_zero = true
+                  when :PBSpecies
-                  newparam = pbChooseTypeList
+                    newparam = pbChooseSpeciesList
-                when :PBAbilities
+                  when :PBTypes
-                  newparam = pbChooseAbilityList
+                    allow_zero = true
-                else
+                    newparam = pbChooseTypeList
-                  allow_zero = true
+                  when :PBAbilities
-                  params = ChooseNumberParams.new
+                    newparam = pbChooseAbilityList
-                  params.setRange(0,65535)
+                  else
-                  params.setCancelValue(-1)
+                    allow_zero = true
-                  newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
+                    params = ChooseNumberParams.new
+                    params.setRange(0,65535)
+                    params.setCancelValue(-1)
+                    newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
+                  end
                 end
-                if newparam && (newparam>0 || (allow_zero && newparam == 0))
+                if !has_param || newparam > 0 || (allow_zero && newparam == 0)
                   havemove = -1
                   for i in 0...realcmds.length
                     havemove = realcmds[i][3] if realcmds[i][0]==newmethod &&
@@ -1324,44 +1336,49 @@ class EvolutionsProperty
               end
             elsif cmd2==2   # Change parameter
               newparam = -1
-              allow_zero = false
               param_type = PBEvolution.getFunction(entry[0], "parameterType")
-              case param_type
+              has_param = !PBEvolution.hasFunction?(entry[0], "parameterType") || param_type != nil
-              when :PBItems
+              if has_param
-                newparam = pbChooseItemList(entry[1])
+                allow_zero = false
-              when :PBMoves
+                case param_type
-                newparam = pbChooseMoveList(entry[1])
+                when :PBItems
-              when :PBSpecies
+                  newparam = pbChooseItemList(entry[1])
-                newparam = pbChooseSpeciesList(entry[1])
+                when :PBMoves
-              when :PBTypes
+                  newparam = pbChooseMoveList(entry[1])
-                allow_zero = true
+                when :PBSpecies
-                newparam = pbChooseTypeList(entry[1])
+                  newparam = pbChooseSpeciesList(entry[1])
-              when :PBAbilities
+                when :PBTypes
-                newparam = pbChooseAbilityList(entry[1])
+                  allow_zero = true
-              else
+                  newparam = pbChooseTypeList(entry[1])
-                allow_zero = true
+                when :PBAbilities
-                params = ChooseNumberParams.new
+                  newparam = pbChooseAbilityList(entry[1])
-                params.setRange(0,65535)
-                params.setDefaultValue(entry[1])
-                params.setCancelValue(-1)
-                newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
-              end
-              if newparam && (newparam>0 || (allow_zero && newparam == 0))
-                havemove = -1
-                for i in 0...realcmds.length
-                  havemove = realcmds[i][3] if realcmds[i][0]==entry[0] &&
-                                               realcmds[i][1]==newparam &&
-                                               realcmds[i][2]==entry[2]
-                end
-                if havemove>=0
-                  realcmds[cmd[1]] = nil
-                  realcmds.compact!
-                  oldsel = havemove
                 else
-                  entry[1] = newparam
+                  allow_zero = true
-                  oldsel = entry[3]
+                  params = ChooseNumberParams.new
+                  params.setRange(0,65535)
+                  params.setDefaultValue(entry[1])
+                  params.setCancelValue(-1)
+                  newparam = pbMessageChooseNumber(_INTL("Choose a parameter."),params)
                 end
-                refreshlist = true
+                if newparam>0 || (allow_zero && newparam == 0)
+                  havemove = -1
+                  for i in 0...realcmds.length
+                    havemove = realcmds[i][3] if realcmds[i][0]==entry[0] &&
+                                                 realcmds[i][1]==newparam &&
+                                                 realcmds[i][2]==entry[2]
+                  end
+                  if havemove>=0
+                    realcmds[cmd[1]] = nil
+                    realcmds.compact!
+                    oldsel = havemove
+                  else
+                    entry[1] = newparam
+                    oldsel = entry[3]
+                  end
+                  refreshlist = true
+                end
+              else
+                pbMessage(_INTL("This evolution method doesn't use a parameter."))
               end
             elsif cmd2==3   # Delete
               realcmds[cmd[1]] = nil