DocRock3r/infinitefusion-e18
1
0
Fork 0
mirror of https://github.com/infinitefusion/infinitefusion-e18.git synced 2025-12-06 06:01:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Maruno17
2021-03-12 23:20:02 +00:00
parent ba1d225b83
commit d8bf4b7fda
37 changed files with 975 additions and 969 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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

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

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

2
Data/Scripts/011_Data/002_Hardcoded data/002_Stat.rb
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
Data/Scripts/011_Data/002_Hardcoded data/011_BattleTerrain.rb
View File

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

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

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

606
Data/Scripts/011_Data/002_Hardcoded data/015_Evolution.rb Normal file
View File

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

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

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

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

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

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

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

3
Data/Scripts/012_Battle/008_BattleHandlers_Items.rb
View File

@@ -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 evos.any? { |e| e[1] != PBEvolution::None && !e[3] } # Not a "None", not a prevolution
if target.pokemon.species_data.get_evolutions(true).length > 0
mults[:defense_multiplier] *= 1.5
end
}

2
Data/Scripts/012_Battle/009_PokeBall_CatchEffects.rb
View File

@@ -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

2
Data/Scripts/013_Overworld/006_PField_Battles.rb
View File

@@ -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)

4
Data/Scripts/013_Overworld/013_PField_DayCare.rb
View File

@@ -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

4
Data/Scripts/015_Items/001_PItem_Items.rb
View File

@@ -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

4
Data/Scripts/015_Items/002_PItem_ItemEffects.rb
View File

@@ -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
}

58
Data/Scripts/016_Pokemon/001_Pokemon.rb
View File

@@ -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
#=============================================================================

2
Data/Scripts/017_UI/021_PScreen_Evolution.rb
View File

@@ -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)

2
Data/Scripts/017_UI/022_PScreen_Trading.rb
View File

@@ -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)

8
Data/Scripts/019_Other battles/004_PBattle_OrgBattleRules.rb
View File

@@ -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))
return false if baby!=pokemon.species
($babySpeciesData[pokemon.species] = pokemon.species_data.get_baby_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

6
Data/Scripts/019_Other battles/005_PBattle_OrgBattleGenerator.rb
View File

@@ -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

11
Data/Scripts/020_System and utilities/004_PSystem_PokemonUtilities.rb
View File

@@ -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)
compatSpecies = (evoSpecies && evoSpecies[0]) ? evoSpecies[0][2] : species
evoSpecies = species_data.get_evolutions(true)
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?(:Ditto)
baby = EvolutionHelper.baby_species(species)
return false if compat.include?(:Undiscovered) || compat.include?(:Ditto)
baby = GameData::Species.get(species).get_baby_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

12
Data/Scripts/021_Debug/004_Editor_Screens.rb
View File

@@ -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)

188
Data/Scripts/021_Debug/007_Editor_DataTypes.rb
View File

@@ -1156,11 +1156,39 @@ end
class EvolutionsProperty
def initialize
@methods = []
(PBEvolution.maxValue + 1).times do |i|
@methods[i] = getConstantName(PBEvolution, i)
@evo_ids = []
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")
has_param = !PBEvolution.hasFunction?(realcmds[i][1], "parameterType") || param_type != nil
if has_param
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
evo_method_data = GameData::Evolution.get(realcmds[i][1])
param_type = evo_method_data.parameter
if param_type.nil?
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)
if newmethod>0
newparam = -1
param_type = PBEvolution.getFunction(newmethod, "parameterType")
has_param = !PBEvolution.hasFunction?(newmethod, "parameterType") || param_type != nil
if has_param
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
newmethodindex = pbMessage(_INTL("Choose an evolution method."),@methods,-1)
if newmethodindex >= 0
newmethod = @evo_ids[newmethodindex]
newparam = edit_parameter(newmethod)
if newparam || GameData::Evolution.get(newmethod).parameter.nil?
existing_evo = -1
for i in 0...realcmds.length
havemove = realcmds[i][3] if realcmds[i][0]==newspecies &&
realcmds[i][1]==newmethod &&
realcmds[i][2]==newparam
existing_evo = realcmds[i][3] if realcmds[i][0]==newspecies &&
realcmds[i][1]==newmethod &&
realcmds[i][2]==newparam
end
if havemove>=0
oldsel = havemove
if existing_evo >= 0
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 &&
realcmds[i][1]==entry[1] &&
realcmds[i][2]==entry[2]
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])
if newmethod>0
havemove = -1
default_index = 0
@evo_ids.each_with_index { |evo, i| default_index = i if evo == entry[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] &&
realcmds[i][1]==newmethod &&
realcmds[i][2]==entry[2]
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
param_type = PBEvolution.getFunction(entry[1], "parameterType")
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
params = ChooseNumberParams.new
params.setRange(0,65535)
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
if GameData::Evolution.get(entry[1]).parameter.nil?
pbMessage(_INTL("This evolution method doesn't use a parameter."))
else
newparam = edit_parameter(entry[1], entry[2])
if newparam
existing_evo = -1
for i in 0...realcmds.length
havemove = realcmds[i][3] if realcmds[i][0]==entry[0] &&
realcmds[i][1]==entry[1] &&
realcmds[i][2]==newparam
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")
if param_type && !GameData.const_defined?(param_type.to_sym)
evo_method_data = GameData::Evolution.get(value[i][1])
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

2
Data/Scripts/021_Debug/009_Editor_Utilities.rb
View File

@@ -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

24
Data/Scripts/022_Compiler/002_Compiler_CompilePBS.rb
View File

@@ -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")
if param_type
evo[2] = csvEnumField!(evo[2], param_type, "Evolutions", species.id_number)
elsif evo[2] && !evo[2].empty?
evo[2] = csvInt!(evo[2])
else
param_type = GameData::Evolution.get(evo[1]).parameter
if param_type.nil?
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
param = csvEnumField!(param, param_type, "Evolutions", section_name)
elsif param && !param.empty?
param = csvInt!(param)
else
if param_type.nil?
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

36
Data/Scripts/022_Compiler/003_Compiler_WritePBS.rb
View File

@@ -331,18 +331,15 @@ 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])))
param_type = PBEvolution.getFunction(evo[1], "parameterType")
has_param = !PBEvolution.hasFunction?(evo[1], "parameterType") || param_type != nil
next if !has_param
if param_type
if GameData.const_defined?(param_type.to_sym)
f.write(evo[2].to_s)
else
evo_type_data = GameData::Evolution.get(evo[1])
param_type = evo_type_data.parameter
f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
if !param_type.nil?
if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
f.write(getConstantName(param_type, evo[2]))
else
f.write(evo[2].to_s)
end
else
f.write(evo[2].to_s)
end
end
f.write("\r\n")
@@ -439,18 +436,15 @@ 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])))
param_type = PBEvolution.getFunction(evo[1], "parameterType")
has_param = !PBEvolution.hasFunction?(evo[1], "parameterType") || param_type != nil
next if !has_param
if param_type
if GameData.const_defined?(param_type.to_sym)
f.write(evo[2].to_s)
else
evo_type_data = GameData::Evolution.get(evo[1])
param_type = evo_type_data.parameter
f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
if !param_type.nil?
if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
f.write(getConstantName(param_type, evo[2]))
else
f.write(evo[2].to_s)
end
else
f.write(evo[2].to_s)
end
end
f.write("\r\n")
@@ -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

2
PBS/Gen 5/pokemon.txt
View File

@@ -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

2
PBS/Gen 7/pokemon.txt
View File

@@ -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

2
PBS/pokemon.txt
View File

@@ -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