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

Yet more script rearranging

Browse Source
This commit is contained in:
Maruno17
2021-04-17 23:45:42 +01:00
parent 96c68e79a3
commit 2ca8a42949
236 changed files with 923 additions and 928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
Data/Scripts/010_Data/001_GameData.rb Normal file
View File

@@ -0,0 +1,211 @@
module GameData
#=============================================================================
# A mixin module for data classes which provides common class methods (called
# by GameData::Thing.method) that provide access to data held within.
# Assumes the data class's data is stored in a class constant hash called DATA.
# For data that is known by a symbol or an ID number.
#=============================================================================
module ClassMethods
def register(hash)
self::DATA[hash[:id]] = self::DATA[hash[:id_number]] = self.new(hash)
end
# @param other [Symbol, self, String, Integer]
# @return [Boolean] whether the given other is defined as a self
def exists?(other)
return false if other.nil?
validate other => [Symbol, self, String, Integer]
other = other.id if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
return !self::DATA[other].nil?
end
# @param other [Symbol, self, String, Integer]
# @return [self]
def get(other)
validate other => [Symbol, self, String, Integer]
return other if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
# if other.is_a?(Integer)
# p "Please switch to symbols, thanks."
# end
raise "Unknown ID #{other}." unless self::DATA.has_key?(other)
return self::DATA[other]
end
# @param other [Symbol, self, String, Integer]
# @return [self, nil]
def try_get(other)
return nil if other.nil?
validate other => [Symbol, self, String, Integer]
return other if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
# if other.is_a?(Integer)
# p "Please switch to symbols, thanks."
# end
return (self::DATA.has_key?(other)) ? self::DATA[other] : nil
end
# Yields all data in order of their id_number.
def each
keys = self::DATA.keys.sort { |a, b| self::DATA[a].id_number <=> self::DATA[b].id_number }
keys.each { |key| yield self::DATA[key] if !key.is_a?(Integer) }
end
def load
const_set(:DATA, load_data("Data/#{self::DATA_FILENAME}"))
end
def save
save_data(self::DATA, "Data/#{self::DATA_FILENAME}")
end
end
#=============================================================================
# A mixin module for data classes which provides common class methods (called
# by GameData::Thing.method) that provide access to data held within.
# Assumes the data class's data is stored in a class constant hash called DATA.
# For data that is only known by a symbol.
#=============================================================================
module ClassMethodsSymbols
def register(hash)
self::DATA[hash[:id]] = self.new(hash)
end
# @param other [Symbol, self, String]
# @return [Boolean] whether the given other is defined as a self
def exists?(other)
return false if other.nil?
validate other => [Symbol, self, String]
other = other.id if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
return !self::DATA[other].nil?
end
# @param other [Symbol, self, String]
# @return [self]
def get(other)
validate other => [Symbol, self, String]
return other if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
raise "Unknown ID #{other}." unless self::DATA.has_key?(other)
return self::DATA[other]
end
# @param other [Symbol, self, String]
# @return [self, nil]
def try_get(other)
return nil if other.nil?
validate other => [Symbol, self, String]
return other if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
return (self::DATA.has_key?(other)) ? self::DATA[other] : nil
end
# Yields all data in alphabetical order.
def each
keys = self::DATA.keys.sort { |a, b| self::DATA[a].real_name <=> self::DATA[b].real_name }
keys.each { |key| yield self::DATA[key] }
end
def load
const_set(:DATA, load_data("Data/#{self::DATA_FILENAME}"))
end
def save
save_data(self::DATA, "Data/#{self::DATA_FILENAME}")
end
end
#=============================================================================
# A mixin module for data classes which provides common class methods (called
# by GameData::Thing.method) that provide access to data held within.
# Assumes the data class's data is stored in a class constant hash called DATA.
# For data that is only known by an ID number.
#=============================================================================
module ClassMethodsIDNumbers
def register(hash)
self::DATA[hash[:id]] = self.new(hash)
end
# @param other [self, Integer]
# @return [Boolean] whether the given other is defined as a self
def exists?(other)
return false if other.nil?
validate other => [self, Integer]
other = other.id if other.is_a?(self)
return !self::DATA[other].nil?
end
# @param other [self, Integer]
# @return [self]
def get(other)
validate other => [self, Integer]
return other if other.is_a?(self)
raise "Unknown ID #{other}." unless self::DATA.has_key?(other)
return self::DATA[other]
end
def try_get(other)
return nil if other.nil?
validate other => [self, Integer]
return other if other.is_a?(self)
return (self::DATA.has_key?(other)) ? self::DATA[other] : nil
end
# Yields all data in numberical order.
def each
keys = self::DATA.keys.sort
keys.each { |key| yield self::DATA[key] }
end
def load
const_set(:DATA, load_data("Data/#{self::DATA_FILENAME}"))
end
def save
save_data(self::DATA, "Data/#{self::DATA_FILENAME}")
end
end
#=============================================================================
# A mixin module for data classes which provides common instance methods
# (called by thing.method) that analyse the data of a particular thing which
# the instance represents.
#=============================================================================
module InstanceMethods
# @param other [Symbol, self.class, String, Integer]
# @return [Boolean] whether other represents the same thing as this thing
def ==(other)
return false if other.nil?
if other.is_a?(Symbol)
return @id == other
elsif other.is_a?(self.class)
return @id == other.id
elsif other.is_a?(String)
return @id_number == other.to_sym
elsif other.is_a?(Integer)
return @id_number == other
end
return false
end
end
#=============================================================================
# A bulk loader method for all data stored in .dat files in the Data folder.
#=============================================================================
def self.load_all
Type.load
Ability.load
Move.load
Item.load
BerryPlant.load
Species.load
Ribbon.load
Encounter.load
TrainerType.load
Trainer.load
Metadata.load
MapMetadata.load
end
end

190
Data/Scripts/010_Data/001_Hardcoded data/001_GrowthRate.rb Normal file
View File

@@ -0,0 +1,190 @@
module GameData
class GrowthRate
attr_reader :id
attr_reader :real_name
attr_reader :exp_values
attr_reader :exp_formula
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
# Calculates the maximum level a Pokémon can attain. This can vary during a
# game, and here is where you would make it do so. Note that this method is
# called by the Compiler, which happens before anything (e.g. Game Switches/
# Variables, the player's data) is loaded, so code in this method should
# check whether the needed variables exist before using them; if they don't,
# this method should return the maximum possible level ever.
# @return [Integer] the maximum level attainable by a Pokémon
def self.max_level
return Settings::MAXIMUM_LEVEL
end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@exp_values = hash[:exp_values]
@exp_formula = hash[:exp_formula]
end
# @return [String] the translated name of this growth rate
def name
return _INTL(@real_name)
end
# @param level [Integer] a level number
# @return [Integer] the minimum Exp needed to be at the given level
def minimum_exp_for_level(level)
return ArgumentError.new("Level #{level} is invalid.") if !level || level <= 0
level = [level, GrowthRate.max_level].min
return @exp_values[level] if level < @exp_values.length
raise "No Exp formula is defined for growth rate #{name}" if !@exp_formula
return @exp_formula.call(level)
end
# @return [Integer] the maximum Exp a Pokémon with this growth rate can have
def maximum_exp
return minimum_exp_for_level(GrowthRate.max_level)
end
# @param exp1 [Integer] an Exp amount
# @param exp2 [Integer] an Exp amount
# @return [Integer] the sum of the two given Exp amounts
def add_exp(exp1, exp2)
return (exp1 + exp2).clamp(0, maximum_exp)
end
# @param exp [Integer] an Exp amount
# @return [Integer] the level of a Pokémon that has the given Exp amount
def level_from_exp(exp)
return ArgumentError.new("Exp amount #{level} is invalid.") if !exp || exp < 0
max = GrowthRate.max_level
return max if exp >= maximum_exp
for level in 1..max
return level - 1 if exp < minimum_exp_for_level(level)
end
return max
end
end
end
#===============================================================================
GameData::GrowthRate.register({
:id => :Medium, # Also known as Medium Fast
:name => _INTL("Medium"),
:exp_values => [-1,
0, 8, 27, 64, 125, 216, 343, 512, 729, 1000,
1331, 1728, 2197, 2744, 3375, 4096, 4913, 5832, 6859, 8000,
9261, 10648, 12167, 13824, 15625, 17576, 19683, 21952, 24389, 27000,
29791, 32768, 35937, 39304, 42875, 46656, 50653, 54872, 59319, 64000,
68921, 74088, 79507, 85184, 91125, 97336, 103823, 110592, 117649, 125000,
132651, 140608, 148877, 157464, 166375, 175616, 185193, 195112, 205379, 216000,
226981, 238328, 250047, 262144, 274625, 287496, 300763, 314432, 328509, 343000,
357911, 373248, 389017, 405224, 421875, 438976, 456533, 474552, 493039, 512000,
531441, 551368, 571787, 592704, 614125, 636056, 658503, 681472, 704969, 729000,
753571, 778688, 804357, 830584, 857375, 884736, 912673, 941192, 970299, 1000000],
:exp_formula => proc { |level| next level ** 3 }
})
# Erratic (600000):
# For levels 0-50: n**3 * (100 - n) / 50
# For levels 51-68: n**3 * (150 - n) / 100
# For levels 69-98: n**3 * 1.274 - (n / 150) - p(n mod 3)
# where p(x) = array(0.000, 0.008, 0.014)[x]
# For levels 99-100: n**3 * (160 - n) / 100
GameData::GrowthRate.register({
:id => :Erratic,
:name => _INTL("Erratic"),
:exp_values => [-1,
0, 15, 52, 122, 237, 406, 637, 942, 1326, 1800,
2369, 3041, 3822, 4719, 5737, 6881, 8155, 9564, 11111, 12800,
14632, 16610, 18737, 21012, 23437, 26012, 28737, 31610, 34632, 37800,
41111, 44564, 48155, 51881, 55737, 59719, 63822, 68041, 72369, 76800,
81326, 85942, 90637, 95406, 100237, 105122, 110052, 115015, 120001, 125000,
131324, 137795, 144410, 151165, 158056, 165079, 172229, 179503, 186894, 194400,
202013, 209728, 217540, 225443, 233431, 241496, 249633, 257834, 267406, 276458,
286328, 296358, 305767, 316074, 326531, 336255, 346965, 357812, 367807, 378880,
390077, 400293, 411686, 423190, 433572, 445239, 457001, 467489, 479378, 491346,
501878, 513934, 526049, 536557, 548720, 560922, 571333, 583539, 591882, 600000],
:exp_formula => proc { |level| next (level ** 4) * 3 / 500 }
})
# Fluctuating (1640000):
# For levels 0-15 : n**3 * (24 + ((n + 1) / 3)) / 50
# For levels 16-35: n**3 * (14 + n) / 50
# For levels 36-100: n**3 * (32 + (n / 2)) / 50
GameData::GrowthRate.register({
:id => :Fluctuating,
:name => _INTL("Fluctuating"),
:exp_values => [-1,
0, 4, 13, 32, 65, 112, 178, 276, 393, 540,
745, 967, 1230, 1591, 1957, 2457, 3046, 3732, 4526, 5440,
6482, 7666, 9003, 10506, 12187, 14060, 16140, 18439, 20974, 23760,
26811, 30146, 33780, 37731, 42017, 46656, 50653, 55969, 60505, 66560,
71677, 78533, 84277, 91998, 98415, 107069, 114205, 123863, 131766, 142500,
151222, 163105, 172697, 185807, 196322, 210739, 222231, 238036, 250562, 267840,
281456, 300293, 315059, 335544, 351520, 373744, 390991, 415050, 433631, 459620,
479600, 507617, 529063, 559209, 582187, 614566, 639146, 673863, 700115, 737280,
765275, 804997, 834809, 877201, 908905, 954084, 987754, 1035837, 1071552, 1122660,
1160499, 1214753, 1254796, 1312322, 1354652, 1415577, 1460276, 1524731, 1571884, 1640000],
:exp_formula => proc { |level|
rate = [82 - (level - 100) / 2.0, 40].max
next (level ** 4) * rate / 5000
}
})
GameData::GrowthRate.register({
:id => :Parabolic, # Also known as Medium Slow
:name => _INTL("Parabolic"),
:exp_values => [-1,
0, 9, 57, 96, 135, 179, 236, 314, 419, 560,
742, 973, 1261, 1612, 2035, 2535, 3120, 3798, 4575, 5460,
6458, 7577, 8825, 10208, 11735, 13411, 15244, 17242, 19411, 21760,
24294, 27021, 29949, 33084, 36435, 40007, 43808, 47846, 52127, 56660,
61450, 66505, 71833, 77440, 83335, 89523, 96012, 102810, 109923, 117360,
125126, 133229, 141677, 150476, 159635, 169159, 179056, 189334, 199999, 211060,
222522, 234393, 246681, 259392, 272535, 286115, 300140, 314618, 329555, 344960,
360838, 377197, 394045, 411388, 429235, 447591, 466464, 485862, 505791, 526260,
547274, 568841, 590969, 613664, 636935, 660787, 685228, 710266, 735907, 762160,
789030, 816525, 844653, 873420, 902835, 932903, 963632, 995030, 1027103, 1059860],
:exp_formula => proc { |level| next ((level ** 3) * 6 / 5) - 15 * (level ** 2) + 100 * level - 140 }
})
GameData::GrowthRate.register({
:id => :Fast,
:name => _INTL("Fast"),
:exp_values => [-1,
0, 6, 21, 51, 100, 172, 274, 409, 583, 800,
1064, 1382, 1757, 2195, 2700, 3276, 3930, 4665, 5487, 6400,
7408, 8518, 9733, 11059, 12500, 14060, 15746, 17561, 19511, 21600,
23832, 26214, 28749, 31443, 34300, 37324, 40522, 43897, 47455, 51200,
55136, 59270, 63605, 68147, 72900, 77868, 83058, 88473, 94119, 100000,
106120, 112486, 119101, 125971, 133100, 140492, 148154, 156089, 164303, 172800,
181584, 190662, 200037, 209715, 219700, 229996, 240610, 251545, 262807, 274400,
286328, 298598, 311213, 324179, 337500, 351180, 365226, 379641, 394431, 409600,
425152, 441094, 457429, 474163, 491300, 508844, 526802, 545177, 563975, 583200,
602856, 622950, 643485, 664467, 685900, 707788, 730138, 752953, 776239, 800000],
:exp_formula => proc { |level| (level ** 3) * 4 / 5 }
})
GameData::GrowthRate.register({
:id => :Slow,
:name => _INTL("Slow"),
:exp_values => [-1,
0, 10, 33, 80, 156, 270, 428, 640, 911, 1250,
1663, 2160, 2746, 3430, 4218, 5120, 6141, 7290, 8573, 10000,
11576, 13310, 15208, 17280, 19531, 21970, 24603, 27440, 30486, 33750,
37238, 40960, 44921, 49130, 53593, 58320, 63316, 68590, 74148, 80000,
86151, 92610, 99383, 106480, 113906, 121670, 129778, 138240, 147061, 156250,
165813, 175760, 186096, 196830, 207968, 219520, 231491, 243890, 256723, 270000,
283726, 297910, 312558, 327680, 343281, 359370, 375953, 393040, 410636, 428750,
447388, 466560, 486271, 506530, 527343, 548720, 570666, 593190, 616298, 640000,
664301, 689210, 714733, 740880, 767656, 795070, 823128, 851840, 881211, 911250,
941963, 973360, 1005446, 1038230, 1071718, 1105920, 1140841, 1176490, 1212873, 1250000],
:exp_formula => proc { |level| (level ** 3) * 5 / 4 }
})

77
Data/Scripts/010_Data/001_Hardcoded data/002_GenderRatio.rb Normal file
View File

@@ -0,0 +1,77 @@
# If a Pokémon's gender ratio is none of :AlwaysMale, :AlwaysFemale or
# :Genderless, then it will choose a random number between 0 and 255 inclusive,
# and compare it to the @female_chance. If the random number is lower than this
# chance, it will be female; otherwise, it will be male.
module GameData
class GenderRatio
attr_reader :id
attr_reader :real_name
attr_reader :female_chance
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@female_chance = hash[:female_chance]
end
# @return [String] the translated name of this gender ratio
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::GenderRatio.register({
:id => :AlwaysMale,
:name => _INTL("Always Male")
})
GameData::GenderRatio.register({
:id => :AlwaysFemale,
:name => _INTL("Always Female")
})
GameData::GenderRatio.register({
:id => :Genderless,
:name => _INTL("Genderless")
})
GameData::GenderRatio.register({
:id => :FemaleOneEighth,
:name => _INTL("Female One Eighth"),
:female_chance => 32
})
GameData::GenderRatio.register({
:id => :Female25Percent,
:name => _INTL("Female 25 Percent"),
:female_chance => 64
})
GameData::GenderRatio.register({
:id => :Female50Percent,
:name => _INTL("Female 50 Percent"),
:female_chance => 128
})
GameData::GenderRatio.register({
:id => :Female75Percent,
:name => _INTL("Female 75 Percent"),
:female_chance => 192
})
GameData::GenderRatio.register({
:id => :FemaleSevenEighths,
:name => _INTL("Female Seven Eighths"),
:female_chance => 224
})

101
Data/Scripts/010_Data/001_Hardcoded data/003_EggGroup.rb Normal file
View File

@@ -0,0 +1,101 @@
module GameData
class EggGroup
attr_reader :id
attr_reader :real_name
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
end
# @return [String] the translated name of this egg group
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::EggGroup.register({
:id => :Undiscovered,
:name => _INTL("Undiscovered")
})
GameData::EggGroup.register({
:id => :Monster,
:name => _INTL("Monster")
})
GameData::EggGroup.register({
:id => :Water1,
:name => _INTL("Water 1")
})
GameData::EggGroup.register({
:id => :Bug,
:name => _INTL("Bug")
})
GameData::EggGroup.register({
:id => :Flying,
:name => _INTL("Flying")
})
GameData::EggGroup.register({
:id => :Field,
:name => _INTL("Field")
})
GameData::EggGroup.register({
:id => :Fairy,
:name => _INTL("Fairy")
})
GameData::EggGroup.register({
:id => :Grass,
:name => _INTL("Grass")
})
GameData::EggGroup.register({
:id => :Humanlike,
:name => _INTL("Humanlike")
})
GameData::EggGroup.register({
:id => :Water3,
:name => _INTL("Water 3")
})
GameData::EggGroup.register({
:id => :Mineral,
:name => _INTL("Mineral")
})
GameData::EggGroup.register({
:id => :Amorphous,
:name => _INTL("Amorphous")
})
GameData::EggGroup.register({
:id => :Water2,
:name => _INTL("Water 2")
})
GameData::EggGroup.register({
:id => :Ditto,
:name => _INTL("Ditto")
})
GameData::EggGroup.register({
:id => :Dragon,
:name => _INTL("Dragon")
})

117
Data/Scripts/010_Data/001_Hardcoded data/004_BodyShape.rb Normal file
View File

@@ -0,0 +1,117 @@
# NOTE: The id_number is only used to determine the order that body shapes are
# listed in the Pokédex search screen. Number 0 (:None) is ignored; they
# start with shape 1.
# "Graphics/Pictures/Pokedex/icon_shapes.png" contains icons for these
# shapes.
module GameData
class BodyShape
attr_reader :id
attr_reader :id_number
attr_reader :real_name
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
end
# @return [String] the translated name of this body shape
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::BodyShape.register({
:id => :Head,
:id_number => 1,
:name => _INTL("Head")
})
GameData::BodyShape.register({
:id => :Serpentine,
:id_number => 2,
:name => _INTL("Serpentine")
})
GameData::BodyShape.register({
:id => :Finned,
:id_number => 3,
:name => _INTL("Finned")
})
GameData::BodyShape.register({
:id => :HeadArms,
:id_number => 4,
:name => _INTL("Head and arms")
})
GameData::BodyShape.register({
:id => :HeadBase,
:id_number => 5,
:name => _INTL("Head and base")
})
GameData::BodyShape.register({
:id => :BipedalTail,
:id_number => 6,
:name => _INTL("Bipedal with tail")
})
GameData::BodyShape.register({
:id => :HeadLegs,
:id_number => 7,
:name => _INTL("Head and legs")
})
GameData::BodyShape.register({
:id => :Quadruped,
:id_number => 8,
:name => _INTL("Quadruped")
})
GameData::BodyShape.register({
:id => :Winged,
:id_number => 9,
:name => _INTL("Winged")
})
GameData::BodyShape.register({
:id => :Multiped,
:id_number => 10,
:name => _INTL("Multiped")
})
GameData::BodyShape.register({
:id => :MultiBody,
:id_number => 11,
:name => _INTL("Multi Body")
})
GameData::BodyShape.register({
:id => :Bipedal,
:id_number => 12,
:name => _INTL("Bipedal")
})
GameData::BodyShape.register({
:id => :MultiWinged,
:id_number => 13,
:name => _INTL("Multi Winged")
})
GameData::BodyShape.register({
:id => :Insectoid,
:id_number => 14,
:name => _INTL("Insectoid")
})

90
Data/Scripts/010_Data/001_Hardcoded data/005_BodyColor.rb Normal file
View File

@@ -0,0 +1,90 @@
# NOTE: The id_number is only used to determine the order that body colors are
# listed in the Pokédex search screen.
module GameData
class BodyColor
attr_reader :id
attr_reader :id_number
attr_reader :real_name
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
end
# @return [String] the translated name of this body color
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::BodyColor.register({
:id => :Red,
:id_number => 0,
:name => _INTL("Red")
})
GameData::BodyColor.register({
:id => :Blue,
:id_number => 1,
:name => _INTL("Blue")
})
GameData::BodyColor.register({
:id => :Yellow,
:id_number => 2,
:name => _INTL("Yellow")
})
GameData::BodyColor.register({
:id => :Green,
:id_number => 3,
:name => _INTL("Green")
})
GameData::BodyColor.register({
:id => :Black,
:id_number => 4,
:name => _INTL("Black")
})
GameData::BodyColor.register({
:id => :Brown,
:id_number => 5,
:name => _INTL("Brown")
})
GameData::BodyColor.register({
:id => :Purple,
:id_number => 6,
:name => _INTL("Purple")
})
GameData::BodyColor.register({
:id => :Gray,
:id_number => 7,
:name => _INTL("Gray")
})
GameData::BodyColor.register({
:id => :White,
:id_number => 8,
:name => _INTL("White")
})
GameData::BodyColor.register({
:id => :Pink,
:id_number => 9,
:name => _INTL("Pink")
})

76
Data/Scripts/010_Data/001_Hardcoded data/006_Habitat.rb Normal file
View File

@@ -0,0 +1,76 @@
module GameData
class Habitat
attr_reader :id
attr_reader :real_name
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
end
# @return [String] the translated name of this habitat
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::Habitat.register({
:id => :None,
:name => _INTL("None")
})
GameData::Habitat.register({
:id => :Grassland,
:name => _INTL("Grassland")
})
GameData::Habitat.register({
:id => :Forest,
:name => _INTL("Forest")
})
GameData::Habitat.register({
:id => :WatersEdge,
:name => _INTL("Water's Edge")
})
GameData::Habitat.register({
:id => :Sea,
:name => _INTL("Sea")
})
GameData::Habitat.register({
:id => :Cave,
:name => _INTL("Cave")
})
GameData::Habitat.register({
:id => :Mountain,
:name => _INTL("Mountain")
})
GameData::Habitat.register({
:id => :RoughTerrain,
:name => _INTL("Rough Terrain")
})
GameData::Habitat.register({
:id => :Urban,
:name => _INTL("Urban")
})
GameData::Habitat.register({
:id => :Rare,
:name => _INTL("Rare")
})

599
Data/Scripts/010_Data/001_Hardcoded data/007_Evolution.rb Normal file
View File

@@ -0,0 +1,599 @@
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|
next pkmn.level >= parameter && $game_screen && $game_screen.weather_type == :None
}
})
GameData::Evolution.register({
:id => :LevelSun,
:parameter => Integer,
:level_up_proc => proc { |pkmn, parameter|
next pkmn.level >= parameter && $game_screen &&
GameData::Weather.get($game_screen.weather_type).category == :Sun
}
})
GameData::Evolution.register({
:id => :LevelRain,
:parameter => Integer,
:level_up_proc => proc { |pkmn, parameter|
next pkmn.level >= parameter && $game_screen &&
[:Rain, :Fog].include?(GameData::Weather.get($game_screen.weather_type).category)
}
})
GameData::Evolution.register({
:id => :LevelSnow,
:parameter => Integer,
:level_up_proc => proc { |pkmn, parameter|
next pkmn.level >= parameter && $game_screen &&
GameData::Weather.get($game_screen.weather_type).category == :Hail
}
})
GameData::Evolution.register({
:id => :LevelSandstorm,
:parameter => Integer,
:level_up_proc => proc { |pkmn, parameter|
next pkmn.level >= parameter && $game_screen &&
GameData::Weather.get($game_screen.weather_type).category == :Sandstorm
}
})
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 pkmn.level >= parameter && $Trainer.has_pokemon_of_type?(:DARK)
}
})
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)
}
})

131
Data/Scripts/010_Data/001_Hardcoded data/008_Stat.rb Normal file
View File

@@ -0,0 +1,131 @@
# The id_number value determines which order the stats are iterated through by
# the "each" methods.
# The pbs_order value determines the order in which the stats are written in
# several PBS files, where base stats/IVs/EVs/EV yields are defined. Only stats
# which are yielded by the "each_main" method can have stat numbers defined in
# those places. The values of pbs_order defined below should start with 0 and
# increase without skipping any numbers.
module GameData
class Stat
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :real_name_brief
attr_reader :type
attr_reader :pbs_order
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
# These stats are defined in PBS files, and should have the :pbs_order
# property.
def self.each_main
self.each { |s| yield s if [:main, :main_battle].include?(s.type) }
end
def self.each_main_battle
self.each { |s| yield s if [:main_battle].include?(s.type) }
end
# These stats have associated stat stages in battle.
def self.each_battle
self.each { |s| yield s if [:main_battle, :battle].include?(s.type) }
end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@real_name_brief = hash[:name_brief] || "None"
@type = hash[:type] || :none
@pbs_order = hash[:pbs_order] || -1
end
# @return [String] the translated name of this stat
def name
return _INTL(@real_name)
end
# @return [String] the translated brief name of this stat
def name_brief
return _INTL(@real_name_brief)
end
end
end
#===============================================================================
GameData::Stat.register({
:id => :HP,
:id_number => 0,
:name => _INTL("HP"),
:name_brief => _INTL("HP"),
:type => :main,
:pbs_order => 0
})
GameData::Stat.register({
:id => :ATTACK,
:id_number => 1,
:name => _INTL("Attack"),
:name_brief => _INTL("Atk"),
:type => :main_battle,
:pbs_order => 1
})
GameData::Stat.register({
:id => :DEFENSE,
:id_number => 2,
:name => _INTL("Defense"),
:name_brief => _INTL("Def"),
:type => :main_battle,
:pbs_order => 2
})
GameData::Stat.register({
:id => :SPECIAL_ATTACK,
:id_number => 3,
:name => _INTL("Special Attack"),
:name_brief => _INTL("SpAtk"),
:type => :main_battle,
:pbs_order => 4
})
GameData::Stat.register({
:id => :SPECIAL_DEFENSE,
:id_number => 4,
:name => _INTL("Special Defense"),
:name_brief => _INTL("SpDef"),
:type => :main_battle,
:pbs_order => 5
})
GameData::Stat.register({
:id => :SPEED,
:id_number => 5,
:name => _INTL("Speed"),
:name_brief => _INTL("Spd"),
:type => :main_battle,
:pbs_order => 3
})
GameData::Stat.register({
:id => :ACCURACY,
:id_number => 6,
:name => _INTL("accuracy"),
:name_brief => _INTL("Acc"),
:type => :battle
})
GameData::Stat.register({
:id => :EVASION,
:id_number => 7,
:name => _INTL("evasiveness"),
:name_brief => _INTL("Eva"),
:type => :battle
})

200
Data/Scripts/010_Data/001_Hardcoded data/009_Nature.rb Normal file
View File

@@ -0,0 +1,200 @@
module GameData
class Nature
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :stat_changes
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@stat_changes = hash[:stat_changes] || []
end
# @return [String] the translated name of this nature
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::Nature.register({
:id => :HARDY,
:id_number => 0,
:name => _INTL("Hardy")
})
GameData::Nature.register({
:id => :LONELY,
:id_number => 1,
:name => _INTL("Lonely"),
:stat_changes => [[:ATTACK, 10], [:DEFENSE, -10]]
})
GameData::Nature.register({
:id => :BRAVE,
:id_number => 2,
:name => _INTL("Brave"),
:stat_changes => [[:ATTACK, 10], [:SPEED, -10]]
})
GameData::Nature.register({
:id => :ADAMANT,
:id_number => 3,
:name => _INTL("Adamant"),
:stat_changes => [[:ATTACK, 10], [:SPECIAL_ATTACK, -10]]
})
GameData::Nature.register({
:id => :NAUGHTY,
:id_number => 4,
:name => _INTL("Naughty"),
:stat_changes => [[:ATTACK, 10], [:SPECIAL_DEFENSE, -10]]
})
GameData::Nature.register({
:id => :BOLD,
:id_number => 5,
:name => _INTL("Bold"),
:stat_changes => [[:DEFENSE, 10], [:ATTACK, -10]]
})
GameData::Nature.register({
:id => :DOCILE,
:id_number => 6,
:name => _INTL("Docile")
})
GameData::Nature.register({
:id => :RELAXED,
:id_number => 7,
:name => _INTL("Relaxed"),
:stat_changes => [[:DEFENSE, 10], [:SPEED, -10]]
})
GameData::Nature.register({
:id => :IMPISH,
:id_number => 8,
:name => _INTL("Impish"),
:stat_changes => [[:DEFENSE, 10], [:SPECIAL_ATTACK, -10]]
})
GameData::Nature.register({
:id => :LAX,
:id_number => 9,
:name => _INTL("Lax"),
:stat_changes => [[:DEFENSE, 10], [:SPECIAL_DEFENSE, -10]]
})
GameData::Nature.register({
:id => :TIMID,
:id_number => 10,
:name => _INTL("Timid"),
:stat_changes => [[:SPEED, 10], [:ATTACK, -10]]
})
GameData::Nature.register({
:id => :HASTY,
:id_number => 11,
:name => _INTL("Hasty"),
:stat_changes => [[:SPEED, 10], [:DEFENSE, -10]]
})
GameData::Nature.register({
:id => :SERIOUS,
:id_number => 12,
:name => _INTL("Serious")
})
GameData::Nature.register({
:id => :JOLLY,
:id_number => 13,
:name => _INTL("Jolly"),
:stat_changes => [[:SPEED, 10], [:SPECIAL_ATTACK, -10]]
})
GameData::Nature.register({
:id => :NAIVE,
:id_number => 14,
:name => _INTL("Naive"),
:stat_changes => [[:SPEED, 10], [:SPECIAL_DEFENSE, -10]]
})
GameData::Nature.register({
:id => :MODEST,
:id_number => 15,
:name => _INTL("Modest"),
:stat_changes => [[:SPECIAL_ATTACK, 10], [:ATTACK, -10]]
})
GameData::Nature.register({
:id => :MILD,
:id_number => 16,
:name => _INTL("Mild"),
:stat_changes => [[:SPECIAL_ATTACK, 10], [:DEFENSE, -10]]
})
GameData::Nature.register({
:id => :QUIET,
:id_number => 17,
:name => _INTL("Quiet"),
:stat_changes => [[:SPECIAL_ATTACK, 10], [:SPEED, -10]]
})
GameData::Nature.register({
:id => :BASHFUL,
:id_number => 18,
:name => _INTL("Bashful")
})
GameData::Nature.register({
:id => :RASH,
:id_number => 19,
:name => _INTL("Rash"),
:stat_changes => [[:SPECIAL_ATTACK, 10], [:SPECIAL_DEFENSE, -10]]
})
GameData::Nature.register({
:id => :CALM,
:id_number => 20,
:name => _INTL("Calm"),
:stat_changes => [[:SPECIAL_DEFENSE, 10], [:ATTACK, -10]]
})
GameData::Nature.register({
:id => :GENTLE,
:id_number => 21,
:name => _INTL("Gentle"),
:stat_changes => [[:SPECIAL_DEFENSE, 10], [:DEFENSE, -10]]
})
GameData::Nature.register({
:id => :SASSY,
:id_number => 22,
:name => _INTL("Sassy"),
:stat_changes => [[:SPECIAL_DEFENSE, 10], [:SPEED, -10]]
})
GameData::Nature.register({
:id => :CAREFUL,
:id_number => 23,
:name => _INTL("Careful"),
:stat_changes => [[:SPECIAL_DEFENSE, 10], [:SPECIAL_ATTACK, -10]]
})
GameData::Nature.register({
:id => :QUIRKY,
:id_number => 24,
:name => _INTL("Quirky")
})

79
Data/Scripts/010_Data/001_Hardcoded data/010_Status.rb Normal file
View File

@@ -0,0 +1,79 @@
# NOTE: The id_number is only used to determine the order of the status icons in
# the graphics containing them. Number 0 (:NONE) is ignored; they start
# with status 1.
# "Graphics/Pictures/statuses.png" also contains icons for being fainted
# and for having Pokérus, in that order, at the bottom of the graphic.
# "Graphics/Pictures/Battle/icon_statuses.png" also contains an icon for
# bad poisoning (toxic), at the bottom of the graphic.
# Both graphics automatically handle varying numbers of defined statuses.
module GameData
class Status
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :animation
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number]
@real_name = hash[:name] || "Unnamed"
@animation = hash[:animation]
end
# @return [String] the translated name of this status condition
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::Status.register({
:id => :NONE,
:id_number => 0,
:name => _INTL("None")
})
GameData::Status.register({
:id => :SLEEP,
:id_number => 1,
:name => _INTL("Sleep"),
:animation => "Sleep"
})
GameData::Status.register({
:id => :POISON,
:id_number => 2,
:name => _INTL("Poison"),
:animation => "Poison"
})
GameData::Status.register({
:id => :BURN,
:id_number => 3,
:name => _INTL("Burn"),
:animation => "Burn"
})
GameData::Status.register({
:id => :PARALYSIS,
:id_number => 4,
:name => _INTL("Paralysis"),
:animation => "Paralysis"
})
GameData::Status.register({
:id => :FROZEN,
:id_number => 5,
:name => _INTL("Frozen"),
:animation => "Frozen"
})

194
Data/Scripts/010_Data/001_Hardcoded data/011_TerrainTag.rb Normal file
View File

@@ -0,0 +1,194 @@
module GameData
class TerrainTag
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :can_surf
attr_reader :waterfall # The main part only, not the crest
attr_reader :waterfall_crest
attr_reader :can_fish
attr_reader :can_dive
attr_reader :deep_bush
attr_reader :shows_grass_rustle
attr_reader :land_wild_encounters
attr_reader :double_wild_encounters
attr_reader :battle_environment
attr_reader :ledge
attr_reader :ice
attr_reader :bridge
attr_reader :shows_reflections
attr_reader :must_walk
attr_reader :ignore_passability
DATA = {}
extend ClassMethods
include InstanceMethods
# @param other [Symbol, self, String, Integer]
# @return [self]
def self.try_get(other)
return self.get(:None) if other.nil?
validate other => [Symbol, self, String, Integer]
return other if other.is_a?(self)
other = other.to_sym if other.is_a?(String)
return (self::DATA.has_key?(other)) ? self::DATA[other] : self.get(:None)
end
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number]
@real_name = hash[:id].to_s || "Unnamed"
@can_surf = hash[:can_surf] || false
@waterfall = hash[:waterfall] || false
@waterfall_crest = hash[:waterfall_crest] || false
@can_fish = hash[:can_fish] || false
@can_dive = hash[:can_dive] || false
@deep_bush = hash[:deep_bush] || false
@shows_grass_rustle = hash[:shows_grass_rustle] || false
@land_wild_encounters = hash[:land_wild_encounters] || false
@double_wild_encounters = hash[:double_wild_encounters] || false
@battle_environment = hash[:battle_environment]
@ledge = hash[:ledge] || false
@ice = hash[:ice] || false
@bridge = hash[:bridge] || false
@shows_reflections = hash[:shows_reflections] || false
@must_walk = hash[:must_walk] || false
@ignore_passability = hash[:ignore_passability] || false
end
def can_surf_freely
return @can_surf && !@waterfall && !@waterfall_crest
end
end
end
#===============================================================================
GameData::TerrainTag.register({
:id => :None,
:id_number => 0
})
GameData::TerrainTag.register({
:id => :Ledge,
:id_number => 1,
:ledge => true
})
GameData::TerrainTag.register({
:id => :Grass,
:id_number => 2,
:shows_grass_rustle => true,
:land_wild_encounters => true,
:battle_environment => :Grass
})
GameData::TerrainTag.register({
:id => :Sand,
:id_number => 3,
:battle_environment => :Sand
})
GameData::TerrainTag.register({
:id => :Rock,
:id_number => 4,
:battle_environment => :Rock
})
GameData::TerrainTag.register({
:id => :DeepWater,
:id_number => 5,
:can_surf => true,
:can_fish => true,
:can_dive => true,
:battle_environment => :MovingWater
})
GameData::TerrainTag.register({
:id => :StillWater,
:id_number => 6,
:can_surf => true,
:can_fish => true,
:battle_environment => :StillWater,
:shows_reflections => true
})
GameData::TerrainTag.register({
:id => :Water,
:id_number => 7,
:can_surf => true,
:can_fish => true,
:battle_environment => :MovingWater
})
GameData::TerrainTag.register({
:id => :Waterfall,
:id_number => 8,
:can_surf => true,
:waterfall => true
})
GameData::TerrainTag.register({
:id => :WaterfallCrest,
:id_number => 9,
:can_surf => true,
:can_fish => true,
:waterfall_crest => true
})
GameData::TerrainTag.register({
:id => :TallGrass,
:id_number => 10,
:deep_bush => true,
:land_wild_encounters => true,
:double_wild_encounters => true,
:battle_environment => :TallGrass,
:must_walk => true
})
GameData::TerrainTag.register({
:id => :UnderwaterGrass,
:id_number => 11,
:land_wild_encounters => true
})
GameData::TerrainTag.register({
:id => :Ice,
:id_number => 12,
:battle_environment => :Ice,
:ice => true,
:must_walk => true
})
GameData::TerrainTag.register({
:id => :Neutral,
:id_number => 13,
:ignore_passability => true
})
# NOTE: This is referenced by ID in an Events.onStepTakenFieldMovement proc that
# adds soot to the Soot Sack if the player walks over one of these tiles.
GameData::TerrainTag.register({
:id => :SootGrass,
:id_number => 14,
:shows_grass_rustle => true,
:land_wild_encounters => true,
:battle_environment => :Grass
})
GameData::TerrainTag.register({
:id => :Bridge,
:id_number => 15,
:bridge => true
})
GameData::TerrainTag.register({
:id => :Puddle,
:id_number => 16,
:battle_environment => :Puddle,
:shows_reflections => true
})

163
Data/Scripts/010_Data/001_Hardcoded data/012_Weather.rb Normal file
View File

@@ -0,0 +1,163 @@
# Category has the following effects:
# - Determines the in-battle weather.
# - Some abilities reduce the encounter rate in certain categories of weather.
# - Some evolution methods check the current weather's category.
# - The :Rain category treats the last listed particle graphic as a water splash rather
# than a raindrop, which behaves differently.
# - :Rain auto-waters berry plants.
# Delta values are per second.
# For the tone_proc, strength goes from 0 to RPG::Weather::MAX_SPRITES (60) and
# will typically be the maximum.
module GameData
class Weather
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :category # :None, :Rain, :Hail, :Sandstorm, :Sun, :Fog
attr_reader :graphics # [[particle file names], [tile file names]]
attr_reader :particle_delta_x
attr_reader :particle_delta_y
attr_reader :particle_delta_opacity
attr_reader :tile_delta_x
attr_reader :tile_delta_y
attr_reader :tone_proc
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number]
@real_name = hash[:id].to_s || "Unnamed"
@category = hash[:category] || :None
@particle_delta_x = hash[:particle_delta_x] || 0
@particle_delta_y = hash[:particle_delta_y] || 0
@particle_delta_opacity = hash[:particle_delta_opacity] || 0
@tile_delta_x = hash[:tile_delta_x] || 0
@tile_delta_y = hash[:tile_delta_y] || 0
@graphics = hash[:graphics] || []
@tone_proc = hash[:tone_proc]
end
def has_particles?
return @graphics[0] && @graphics[0].length > 0
end
def has_tiles?
return @graphics[1] && @graphics[1].length > 0
end
def tone(strength)
return (@tone_proc) ? @tone_proc.call(strength) : Tone.new(0, 0, 0, 0)
end
end
end
#===============================================================================
GameData::Weather.register({
:id => :None,
:id_number => 0 # Must be 0 (preset RMXP weather)
})
GameData::Weather.register({
:id => :Rain,
:id_number => 1, # Must be 1 (preset RMXP weather)
:category => :Rain,
:graphics => [["rain_1", "rain_2", "rain_3", "rain_4"]], # Last is splash
:particle_delta_x => -1200,
:particle_delta_y => 4800,
:tone_proc => proc { |strength|
next Tone.new(-strength * 3 / 4, -strength * 3 / 4, -strength * 3 / 4, 10)
}
})
# NOTE: This randomly flashes the screen in RPG::Weather#update.
GameData::Weather.register({
:id => :Storm,
:id_number => 2, # Must be 2 (preset RMXP weather)
:category => :Rain,
:graphics => [["storm_1", "storm_2", "storm_3", "storm_4"]], # Last is splash
:particle_delta_x => -4800,
:particle_delta_y => 4800,
:tone_proc => proc { |strength|
next Tone.new(-strength * 3 / 2, -strength * 3 / 2, -strength * 3 / 2, 20)
}
})
# NOTE: This alters the movement of snow particles in RPG::Weather#update_sprite_position.
GameData::Weather.register({
:id => :Snow,
:id_number => 3, # Must be 3 (preset RMXP weather)
:category => :Hail,
:graphics => [["hail_1", "hail_2", "hail_3"]],
:particle_delta_x => -240,
:particle_delta_y => 240,
:tone_proc => proc { |strength|
next Tone.new(strength / 2, strength / 2, strength / 2, 0)
}
})
GameData::Weather.register({
:id => :Blizzard,
:id_number => 4,
:category => :Hail,
:graphics => [["blizzard_1", "blizzard_2", "blizzard_3", "blizzard_4"], ["blizzard_tile"]],
:particle_delta_x => -960,
:particle_delta_y => 240,
:tile_delta_x => -1440,
:tile_delta_y => 720,
:tone_proc => proc { |strength|
next Tone.new(strength * 3 / 4, strength * 3 / 4, strength * 3 / 4, 0)
}
})
GameData::Weather.register({
:id => :Sandstorm,
:id_number => 5,
:category => :Sandstorm,
:graphics => [["sandstorm_1", "sandstorm_2", "sandstorm_3", "sandstorm_4"], ["sandstorm_tile"]],
:particle_delta_x => -1200,
:particle_delta_y => 640,
:tile_delta_x => -720,
:tile_delta_y => 360,
:tone_proc => proc { |strength|
next Tone.new(strength / 2, 0, -strength / 2, 0)
}
})
GameData::Weather.register({
:id => :HeavyRain,
:id_number => 6,
:category => :Rain,
:graphics => [["storm_1", "storm_2", "storm_3", "storm_4"]], # Last is splash
:particle_delta_x => -4800,
:particle_delta_y => 4800,
:tone_proc => proc { |strength|
next Tone.new(-strength * 3 / 2, -strength * 3 / 2, -strength * 3 / 2, 20)
}
})
# NOTE: This alters the screen tone in RPG::Weather#update_screen_tone.
GameData::Weather.register({
:id => :Sun,
:id_number => 7,
:category => :Sun,
:tone_proc => proc { |strength|
next Tone.new(64, 64, 32, 0)
}
})
GameData::Weather.register({
:id => :Fog,
:category => :Fog,
:id_number => 8,
:tile_delta_x => -32,
:tile_delta_y => 0,
:graphics => [nil, ["fog_tile"]]
})

197
Data/Scripts/010_Data/001_Hardcoded data/013_EncounterType.rb Normal file
View File

@@ -0,0 +1,197 @@
module GameData
class EncounterType
attr_reader :id
attr_reader :real_name
attr_reader :type # :land, :cave, :water, :fishing, :contest, :none
attr_reader :trigger_chance
attr_reader :old_slots
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"
@type = hash[:type] || :none
@trigger_chance = hash[:trigger_chance] || 0
@old_slots = hash[:old_slots]
end
end
end
#===============================================================================
GameData::EncounterType.register({
:id => :Land,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :LandDay,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :LandNight,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :LandMorning,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :LandAfternoon,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :LandEvening,
:type => :land,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :Cave,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :CaveDay,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :CaveNight,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :CaveMorning,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :CaveAfternoon,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :CaveEvening,
:type => :cave,
:trigger_chance => 5,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})
GameData::EncounterType.register({
:id => :Water,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :WaterDay,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :WaterNight,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :WaterMorning,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :WaterAfternoon,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :WaterEvening,
:type => :water,
:trigger_chance => 2,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :OldRod,
:type => :fishing,
:old_slots => [70, 30]
})
GameData::EncounterType.register({
:id => :GoodRod,
:type => :fishing,
:old_slots => [60, 20, 20]
})
GameData::EncounterType.register({
:id => :SuperRod,
:type => :fishing,
:old_slots => [40, 40, 15, 4, 1]
})
GameData::EncounterType.register({
:id => :RockSmash,
:type => :none,
:trigger_chance => 50,
:old_slots => [60, 30, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :HeadbuttLow,
:type => :none,
:old_slots => [30, 25, 20, 10, 5, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :HeadbuttHigh,
:type => :none,
:old_slots => [30, 25, 20, 10, 5, 5, 4, 1]
})
GameData::EncounterType.register({
:id => :BugContest,
:type => :contest,
:trigger_chance => 21,
:old_slots => [20, 20, 10, 10, 10, 10, 5, 5, 4, 4, 1, 1]
})

131
Data/Scripts/010_Data/001_Hardcoded data/014_Environment.rb Normal file
View File

@@ -0,0 +1,131 @@
module GameData
class Environment
attr_reader :id
attr_reader :real_name
attr_reader :battle_base
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@battle_base = hash[:battle_base]
end
# @return [String] the translated name of this environment
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::Environment.register({
:id => :None,
:name => _INTL("None")
})
GameData::Environment.register({
:id => :Grass,
:name => _INTL("Grass"),
:battle_base => "grass"
})
GameData::Environment.register({
:id => :TallGrass,
:name => _INTL("Tall grass"),
:battle_base => "grass"
})
GameData::Environment.register({
:id => :MovingWater,
:name => _INTL("Moving water"),
:battle_base => "water"
})
GameData::Environment.register({
:id => :StillWater,
:name => _INTL("Still water"),
:battle_base => "water"
})
GameData::Environment.register({
:id => :Puddle,
:name => _INTL("Puddle"),
:battle_basec => "puddle"
})
GameData::Environment.register({
:id => :Underwater,
:name => _INTL("Underwater")
})
GameData::Environment.register({
:id => :Cave,
:name => _INTL("Cave")
})
GameData::Environment.register({
:id => :Rock,
:name => _INTL("Rock")
})
GameData::Environment.register({
:id => :Sand,
:name => _INTL("Sand"),
:battle_base => "sand"
})
GameData::Environment.register({
:id => :Forest,
:name => _INTL("Forest")
})
GameData::Environment.register({
:id => :ForestGrass,
:name => _INTL("Forest grass"),
:battle_base => "grass"
})
GameData::Environment.register({
:id => :Snow,
:name => _INTL("Snow")
})
GameData::Environment.register({
:id => :Ice,
:name => _INTL("Ice"),
:battle_base => "ice"
})
GameData::Environment.register({
:id => :Volcano,
:name => _INTL("Volcano")
})
GameData::Environment.register({
:id => :Graveyard,
:name => _INTL("Graveyard")
})
GameData::Environment.register({
:id => :Sky,
:name => _INTL("Sky")
})
GameData::Environment.register({
:id => :Space,
:name => _INTL("Space")
})
GameData::Environment.register({
:id => :UltraSpace,
:name => _INTL("Ultra Space")
})

81
Data/Scripts/010_Data/001_Hardcoded data/015_BattleWeather.rb Normal file
View File

@@ -0,0 +1,81 @@
module GameData
class BattleWeather
attr_reader :id
attr_reader :real_name
attr_reader :animation
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@animation = hash[:animation]
end
# @return [String] the translated name of this battle weather
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::BattleWeather.register({
:id => :None,
:name => _INTL("None")
})
GameData::BattleWeather.register({
:id => :Sun,
:name => _INTL("Sun"),
:animation => "Sun"
})
GameData::BattleWeather.register({
:id => :Rain,
:name => _INTL("Rain"),
:animation => "Rain"
})
GameData::BattleWeather.register({
:id => :Sandstorm,
:name => _INTL("Sandstorm"),
:animation => "Sandstorm"
})
GameData::BattleWeather.register({
:id => :Hail,
:name => _INTL("Hail"),
:animation => "Hail"
})
GameData::BattleWeather.register({
:id => :HarshSun,
:name => _INTL("Harsh Sun"),
:animation => "HarshSun"
})
GameData::BattleWeather.register({
:id => :HeavyRain,
:name => _INTL("Heavy Rain"),
:animation => "HeavyRain"
})
GameData::BattleWeather.register({
:id => :StrongWinds,
:name => _INTL("Strong Winds"),
:animation => "StrongWinds"
})
GameData::BattleWeather.register({
:id => :ShadowSky,
:name => _INTL("Shadow Sky"),
:animation => "ShadowSky"
})

58
Data/Scripts/010_Data/001_Hardcoded data/016_BattleTerrain.rb Normal file
View File

@@ -0,0 +1,58 @@
# These are in-battle terrain effects caused by moves like Electric Terrain.
module GameData
class BattleTerrain
attr_reader :id
attr_reader :real_name
attr_reader :animation
DATA = {}
extend ClassMethodsSymbols
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@animation = hash[:animation]
end
# @return [String] the translated name of this battle terrain
def name
return _INTL(@real_name)
end
end
end
#===============================================================================
GameData::BattleTerrain.register({
:id => :None,
:name => _INTL("None")
})
GameData::BattleTerrain.register({
:id => :Electric,
:name => _INTL("Electric"),
:animation => "ElectricTerrain"
})
GameData::BattleTerrain.register({
:id => :Grassy,
:name => _INTL("Grassy"),
:animation => "GrassyTerrain"
})
GameData::BattleTerrain.register({
:id => :Misty,
:name => _INTL("Misty"),
:animation => "MistyTerrain"
})
GameData::BattleTerrain.register({
:id => :Psychic,
:name => _INTL("Psychic"),
:animation => "PsychicTerrain"
})

194
Data/Scripts/010_Data/001_Hardcoded data/017_Target.rb Normal file
View File

@@ -0,0 +1,194 @@
# NOTE: If adding a new target, you will need to add code in several places to
# make them work properly:
# - def pbFindTargets
# - def pbMoveCanTarget?
# - def pbCreateTargetTexts
# - def pbFirstTarget
# - def pbTargetsMultiple?
module GameData
class Target
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :num_targets # 0, 1 or 2 (meaning 2+)
attr_reader :targets_foe # Is able to target one or more foes
attr_reader :targets_all # Crafty Shield can't protect from these moves
attr_reader :affects_foe_side # Pressure also affects these moves
attr_reader :long_range # Hits non-adjacent targets
DATA = {}
extend ClassMethods
include InstanceMethods
def self.load; end
def self.save; end
def initialize(hash)
@id = hash[:id]
@real_name = hash[:name] || "Unnamed"
@num_targets = hash[:num_targets] || 0
@targets_foe = hash[:targets_foe] || false
@targets_all = hash[:targets_all] || false
@affects_foe_side = hash[:affects_foe_side] || false
@long_range = hash[:long_range] || false
end
# @return [String] the translated name of this target
def name
return _INTL(@real_name)
end
def can_choose_distant_target?
return @num_targets == 1 && @long_range
end
def can_target_one_foe?
return @num_targets == 1 && @targets_foe
end
end
end
#===============================================================================
# Bide, Counter, Metal Burst, Mirror Coat (calculate a target)
GameData::Target.register({
:id => :None,
:id_number => 1,
:name => _INTL("None")
})
GameData::Target.register({
:id => :User,
:id_number => 10,
:name => _INTL("User")
})
# Aromatic Mist, Helping Hand, Hold Hands
GameData::Target.register({
:id => :NearAlly,
:id_number => 100,
:name => _INTL("Near Ally"),
:num_targets => 1
})
# Acupressure
GameData::Target.register({
:id => :UserOrNearAlly,
:id_number => 200,
:name => _INTL("User or Near Ally"),
:num_targets => 1
})
# Aromatherapy, Gear Up, Heal Bell, Life Dew, Magnetic Flux, Howl (in Gen 8+)
GameData::Target.register({
:id => :UserAndAllies,
:id_number => 5,
:name => _INTL("User and Allies"),
:num_targets => 2,
:long_range => true
})
# Me First
GameData::Target.register({
:id => :NearFoe,
:id_number => 400,
:name => _INTL("Near Foe"),
:num_targets => 1,
:targets_foe => true
})
# Petal Dance, Outrage, Struggle, Thrash, Uproar
GameData::Target.register({
:id => :RandomNearFoe,
:id_number => 2,
:name => _INTL("Random Near Foe"),
:num_targets => 1,
:targets_foe => true
})
GameData::Target.register({
:id => :AllNearFoes,
:id_number => 4,
:name => _INTL("All Near Foes"),
:num_targets => 2,
:targets_foe => true
})
# For throwing a Poké Ball
GameData::Target.register({
:id => :Foe,
:id_number => 9,
:name => _INTL("Foe"),
:num_targets => 1,
:targets_foe => true,
:long_range => true
})
# Unused
GameData::Target.register({
:id => :AllFoes,
:id_number => 6,
:name => _INTL("All Foes"),
:num_targets => 2,
:targets_foe => true,
:long_range => true
})
GameData::Target.register({
:id => :NearOther,
:id_number => 0,
:name => _INTL("Near Other"),
:num_targets => 1,
:targets_foe => true
})
GameData::Target.register({
:id => :AllNearOthers,
:id_number => 8,
:name => _INTL("All Near Others"),
:num_targets => 2,
:targets_foe => true
})
# Most Flying-type moves, pulse moves (hits non-near targets)
GameData::Target.register({
:id => :Other,
:id_number => 3,
:name => _INTL("Other"),
:num_targets => 1,
:targets_foe => true,
:long_range => true
})
# Flower Shield, Perish Song, Rototiller, Teatime
GameData::Target.register({
:id => :AllBattlers,
:id_number => 7,
:name => _INTL("All Battlers"),
:num_targets => 2,
:targets_foe => true,
:targets_all => true,
:long_range => true
})
GameData::Target.register({
:id => :UserSide,
:id_number => 40,
:name => _INTL("User Side")
})
# Entry hazards
GameData::Target.register({
:id => :FoeSide,
:id_number => 80,
:name => _INTL("Foe Side"),
:affects_foe_side => true
})
GameData::Target.register({
:id => :BothSides,
:id_number => 20,
:name => _INTL("Both Sides"),
:affects_foe_side => true
})

107
Data/Scripts/010_Data/002_PBS data/001_MiscPBSData.rb Normal file
View File

@@ -0,0 +1,107 @@
#===============================================================================
# Data caches.
#===============================================================================
class PokemonTemp
attr_accessor :townMapData
attr_accessor :phoneData
attr_accessor :speciesShadowMovesets
attr_accessor :regionalDexes
attr_accessor :battleAnims
attr_accessor :moveToAnim
attr_accessor :mapInfos
end
def pbClearData
if $PokemonTemp
$PokemonTemp.townMapData = nil
$PokemonTemp.phoneData = nil
$PokemonTemp.speciesShadowMovesets = nil
$PokemonTemp.regionalDexes = nil
$PokemonTemp.battleAnims = nil
$PokemonTemp.moveToAnim = nil
$PokemonTemp.mapInfos = nil
end
MapFactoryHelper.clear
$PokemonEncounters.setup($game_map.map_id) if $game_map && $PokemonEncounters
if pbRgssExists?("Data/Tilesets.rxdata")
$data_tilesets = load_data("Data/Tilesets.rxdata")
end
end
#===============================================================================
# Method to get Town Map data.
#===============================================================================
def pbLoadTownMapData
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.townMapData
$PokemonTemp.townMapData = load_data("Data/town_map.dat")
end
return $PokemonTemp.townMapData
end
#===============================================================================
# Method to get phone call data.
#===============================================================================
def pbLoadPhoneData
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.phoneData
if pbRgssExists?("Data/phone.dat")
$PokemonTemp.phoneData = load_data("Data/phone.dat")
end
end
return $PokemonTemp.phoneData
end
#===============================================================================
# Method to get Shadow Pokémon moveset data.
#===============================================================================
def pbLoadShadowMovesets
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.speciesShadowMovesets
$PokemonTemp.speciesShadowMovesets = load_data("Data/shadow_movesets.dat") || []
end
return $PokemonTemp.speciesShadowMovesets
end
#===============================================================================
# Method to get Regional Dexes data.
#===============================================================================
def pbLoadRegionalDexes
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.regionalDexes
$PokemonTemp.regionalDexes = load_data("Data/regional_dexes.dat")
end
return $PokemonTemp.regionalDexes
end
#===============================================================================
# Methods relating to battle animations data.
#===============================================================================
def pbLoadBattleAnimations
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.battleAnims
if pbRgssExists?("Data/PkmnAnimations.rxdata")
$PokemonTemp.battleAnims = load_data("Data/PkmnAnimations.rxdata")
end
end
return $PokemonTemp.battleAnims
end
def pbLoadMoveToAnim
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.moveToAnim
$PokemonTemp.moveToAnim = load_data("Data/move2anim.dat") || []
end
return $PokemonTemp.moveToAnim
end
#===============================================================================
# Method relating to map infos data.
#===============================================================================
def pbLoadMapInfos
$PokemonTemp = PokemonTemp.new if !$PokemonTemp
if !$PokemonTemp.mapInfos
$PokemonTemp.mapInfos = load_data("Data/MapInfos.rxdata")
end
return $PokemonTemp.mapInfos
end

31
Data/Scripts/010_Data/002_PBS data/002_PhoneDatabase.rb Normal file
View File

@@ -0,0 +1,31 @@
#===============================================================================
# Phone data
#===============================================================================
class PhoneDatabase
attr_accessor :generics
attr_accessor :greetings
attr_accessor :greetingsMorning
attr_accessor :greetingsEvening
attr_accessor :bodies1
attr_accessor :bodies2
attr_accessor :battleRequests
attr_accessor :trainers
def initialize
@generics = []
@greetings = []
@greetingsMorning = []
@greetingsEvening = []
@bodies1 = []
@bodies2 = []
@battleRequests = []
@trainers = []
end
end
module PhoneMsgType
Generic = 0
Greeting = 1
Body = 2
BattleRequest = 3
end

132
Data/Scripts/010_Data/002_PBS data/003_Type.rb Normal file
View File

@@ -0,0 +1,132 @@
module GameData
class Type
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :special_type
attr_reader :pseudo_type
attr_reader :weaknesses
attr_reader :resistances
attr_reader :immunities
DATA = {}
DATA_FILENAME = "types.dat"
SCHEMA = {
"Name" => [1, "s"],
"InternalName" => [2, "s"],
"IsPseudoType" => [3, "b"],
"IsSpecialType" => [4, "b"],
"Weaknesses" => [5, "*s"],
"Resistances" => [6, "*s"],
"Immunities" => [7, "*s"]
}
extend ClassMethods
include InstanceMethods
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@pseudo_type = hash[:pseudo_type] || false
@special_type = hash[:special_type] || false
@weaknesses = hash[:weaknesses] || []
@weaknesses = [@weaknesses] if !@weaknesses.is_a?(Array)
@resistances = hash[:resistances] || []
@resistances = [@resistances] if !@resistances.is_a?(Array)
@immunities = hash[:immunities] || []
@immunities = [@immunities] if !@immunities.is_a?(Array)
end
# @return [String] the translated name of this item
def name
return pbGetMessage(MessageTypes::Types, @id_number)
end
def physical?; return !@special_type; end
def special?; return @special_type; end
def effectiveness(other_type)
return Effectiveness::NORMAL_EFFECTIVE_ONE if !other_type
return Effectiveness::SUPER_EFFECTIVE_ONE if @weaknesses.include?(other_type)
return Effectiveness::NOT_VERY_EFFECTIVE_ONE if @resistances.include?(other_type)
return Effectiveness::INEFFECTIVE if @immunities.include?(other_type)
return Effectiveness::NORMAL_EFFECTIVE_ONE
end
end
end
#===============================================================================
module Effectiveness
INEFFECTIVE = 0
NOT_VERY_EFFECTIVE_ONE = 1
NORMAL_EFFECTIVE_ONE = 2
SUPER_EFFECTIVE_ONE = 4
NORMAL_EFFECTIVE = NORMAL_EFFECTIVE_ONE ** 3
module_function
def ineffective?(value)
return value == INEFFECTIVE
end
def not_very_effective?(value)
return value > INEFFECTIVE && value < NORMAL_EFFECTIVE
end
def resistant?(value)
return value < NORMAL_EFFECTIVE
end
def normal?(value)
return value == NORMAL_EFFECTIVE
end
def super_effective?(value)
return value > NORMAL_EFFECTIVE
end
def ineffective_type?(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
value = calculate(attack_type, target_type1, target_type2, target_type3)
return ineffective?(value)
end
def not_very_effective_type?(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
value = calculate(attack_type, target_type1, target_type2, target_type3)
return not_very_effective?(value)
end
def resistant_type?(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
value = calculate(attack_type, target_type1, target_type2, target_type3)
return resistant?(value)
end
def normal_type?(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
value = calculate(attack_type, target_type1, target_type2, target_type3)
return normal?(value)
end
def super_effective_type?(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
value = calculate(attack_type, target_type1, target_type2, target_type3)
return super_effective?(value)
end
def calculate_one(attack_type, defend_type)
return GameData::Type.get(defend_type).effectiveness(attack_type)
end
def calculate(attack_type, defend_type1, defend_type2 = nil, defend_type3 = nil)
mod1 = calculate_one(attack_type, defend_type1)
mod2 = NORMAL_EFFECTIVE_ONE
mod3 = NORMAL_EFFECTIVE_ONE
if defend_type2 && defend_type1 != defend_type2
mod2 = calculate_one(attack_type, defend_type2)
end
if defend_type3 && defend_type1 != defend_type3 && defend_type2 != defend_type3
mod3 = calculate_one(attack_type, defend_type3)
end
return mod1 * mod2 * mod3
end
end

31
Data/Scripts/010_Data/002_PBS data/004_Ability.rb Normal file
View File

@@ -0,0 +1,31 @@
module GameData
class Ability
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :real_description
DATA = {}
DATA_FILENAME = "abilities.dat"
extend ClassMethods
include InstanceMethods
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@real_description = hash[:description] || "???"
end
# @return [String] the translated name of this ability
def name
return pbGetMessage(MessageTypes::Abilities, @id_number)
end
# @return [String] the translated description of this ability
def description
return pbGetMessage(MessageTypes::AbilityDescs, @id_number)
end
end
end

85
Data/Scripts/010_Data/002_PBS data/005_Move.rb Normal file
View File

@@ -0,0 +1,85 @@
module GameData
class Move
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :function_code
attr_reader :base_damage
attr_reader :type
attr_reader :category
attr_reader :accuracy
attr_reader :total_pp
attr_reader :effect_chance
attr_reader :target
attr_reader :priority
attr_reader :flags
attr_reader :real_description
DATA = {}
DATA_FILENAME = "moves.dat"
extend ClassMethods
include InstanceMethods
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@function_code = hash[:function_code]
@base_damage = hash[:base_damage]
@type = hash[:type]
@category = hash[:category]
@accuracy = hash[:accuracy]
@total_pp = hash[:total_pp]
@effect_chance = hash[:effect_chance]
@target = hash[:target]
@priority = hash[:priority]
@flags = hash[:flags]
@real_description = hash[:description] || "???"
end
# @return [String] the translated name of this move
def name
return pbGetMessage(MessageTypes::Moves, @id_number)
end
# @return [String] the translated description of this move
def description
return pbGetMessage(MessageTypes::MoveDescriptions, @id_number)
end
def physical?
return false if @base_damage == 0
return @category == 0 if Settings::MOVE_CATEGORY_PER_MOVE
return GameData::Type.get(@type).physical?
end
def special?
return false if @base_damage == 0
return @category == 1 if Settings::MOVE_CATEGORY_PER_MOVE
return GameData::Type.get(@type).special?
end
def hidden_move?
GameData::Item.each do |i|
return true if i.is_HM? && i.move == @id
end
return false
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetMoveData(move_id, move_data_type = -1)
Deprecation.warn_method('pbGetMoveData', 'v20', 'GameData::Move.get(move_id)')
return GameData::Move.get(move_id)
end
# @deprecated This alias is slated to be removed in v20.
def pbIsHiddenMove?(move)
Deprecation.warn_method('pbIsHiddenMove?', 'v20', 'GameData::Move.get(move).hidden_move?')
return GameData::Move.get(move).hidden_move?
end

302
Data/Scripts/010_Data/002_PBS data/006_Item.rb Normal file
View File

@@ -0,0 +1,302 @@
module GameData
class Item
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :real_name_plural
attr_reader :pocket
attr_reader :price
attr_reader :real_description
attr_reader :field_use
attr_reader :battle_use
attr_reader :type
attr_reader :move
DATA = {}
DATA_FILENAME = "items.dat"
extend ClassMethods
include InstanceMethods
def self.icon_filename(item)
return "Graphics/Items/back" if item.nil?
item_data = self.try_get(item)
return "Graphics/Items/000" if item_data.nil?
# Check for files
ret = sprintf("Graphics/Items/%s", item_data.id)
return ret if pbResolveBitmap(ret)
# Check for TM/HM type icons
if item_data.is_machine?
move_type = GameData::Move.get(item_data.move).type
type_data = GameData::Type.get(move_type)
ret = sprintf("Graphics/Items/machine_%s", type_data.id)
return ret if pbResolveBitmap(ret)
end
return "Graphics/Items/000"
end
def self.held_icon_filename(item)
item_data = self.try_get(item)
return nil if !item_data
name_base = (item_data.is_mail?) ? "mail" : "item"
# Check for files
ret = sprintf("Graphics/Pictures/Party/icon_%s_%s", name_base, item_data.id)
return ret if pbResolveBitmap(ret)
return sprintf("Graphics/Pictures/Party/icon_%s", name_base)
end
def self.mail_filename(item)
item_data = self.try_get(item)
return nil if !item_data
# Check for files
ret = sprintf("Graphics/Pictures/Mail/mail_%s", item_data.id)
return pbResolveBitmap(ret) ? ret : nil
end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@real_name_plural = hash[:name_plural] || "Unnamed"
@pocket = hash[:pocket] || 1
@price = hash[:price] || 0
@real_description = hash[:description] || "???"
@field_use = hash[:field_use] || 0
@battle_use = hash[:battle_use] || 0
@type = hash[:type] || 0
@move = hash[:move]
end
# @return [String] the translated name of this item
def name
return pbGetMessage(MessageTypes::Items, @id_number)
end
# @return [String] the translated plural version of the name of this item
def name_plural
return pbGetMessage(MessageTypes::ItemPlurals, @id_number)
end
# @return [String] the translated description of this item
def description
return pbGetMessage(MessageTypes::ItemDescriptions, @id_number)
end
def is_TM?; return @field_use == 3; end
def is_HM?; return @field_use == 4; end
def is_TR?; return @field_use == 6; end
def is_machine?; return is_TM? || is_HM? || is_TR?; end
def is_mail?; return @type == 1 || @type == 2; end
def is_icon_mail?; return @type == 2; end
def is_poke_ball?; return @type == 3 || @type == 4; end
def is_snag_ball?; return @type == 3 || (@type == 4 && $Trainer.has_snag_machine); end
def is_berry?; return @type == 5; end
def is_key_item?; return @type == 6; end
def is_evolution_stone?; return @type == 7; end
def is_fossil?; return @type == 8; end
def is_apricorn?; return @type == 9; end
def is_gem?; return @type == 10; end
def is_mulch?; return @type == 11; end
def is_mega_stone?; return @type == 12; end # Does NOT include Red Orb/Blue Orb
def is_important?
return true if is_key_item? || is_HM? || is_TM?
return false
end
def can_hold?; return !is_important?; end
def unlosable?(species, ability)
return false if species == :ARCEUS && ability != :MULTITYPE
return false if species == :SILVALLY && ability != :RKSSYSTEM
combos = {
:ARCEUS => [:FISTPLATE, :FIGHTINIUMZ,
:SKYPLATE, :FLYINIUMZ,
:TOXICPLATE, :POISONIUMZ,
:EARTHPLATE, :GROUNDIUMZ,
:STONEPLATE, :ROCKIUMZ,
:INSECTPLATE, :BUGINIUMZ,
:SPOOKYPLATE, :GHOSTIUMZ,
:IRONPLATE, :STEELIUMZ,
:FLAMEPLATE, :FIRIUMZ,
:SPLASHPLATE, :WATERIUMZ,
:MEADOWPLATE, :GRASSIUMZ,
:ZAPPLATE, :ELECTRIUMZ,
:MINDPLATE, :PSYCHIUMZ,
:ICICLEPLATE, :ICIUMZ,
:DRACOPLATE, :DRAGONIUMZ,
:DREADPLATE, :DARKINIUMZ,
:PIXIEPLATE, :FAIRIUMZ],
:SILVALLY => [:FIGHTINGMEMORY,
:FLYINGMEMORY,
:POISONMEMORY,
:GROUNDMEMORY,
:ROCKMEMORY,
:BUGMEMORY,
:GHOSTMEMORY,
:STEELMEMORY,
:FIREMEMORY,
:WATERMEMORY,
:GRASSMEMORY,
:ELECTRICMEMORY,
:PSYCHICMEMORY,
:ICEMEMORY,
:DRAGONMEMORY,
:DARKMEMORY,
:FAIRYMEMORY],
:GIRATINA => [:GRISEOUSORB],
:GENESECT => [:BURNDRIVE, :CHILLDRIVE, :DOUSEDRIVE, :SHOCKDRIVE],
:KYOGRE => [:BLUEORB],
:GROUDON => [:REDORB]
}
return combos[species] && combos[species].include?(@id)
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetPocket(item)
Deprecation.warn_method('pbGetPocket', 'v20', 'GameData::Item.get(item).pocket')
return GameData::Item.get(item).pocket
end
# @deprecated This alias is slated to be removed in v20.
def pbGetPrice(item)
Deprecation.warn_method('pbGetPrice', 'v20', 'GameData::Item.get(item).price')
return GameData::Item.get(item).price
end
# @deprecated This alias is slated to be removed in v20.
def pbGetMachine(item)
Deprecation.warn_method('pbGetMachine', 'v20', 'GameData::Item.get(item).move')
return GameData::Item.get(item).move
end
# @deprecated This alias is slated to be removed in v20.
def pbIsTechnicalMachine?(item)
Deprecation.warn_method('pbIsTechnicalMachine?', 'v20', 'GameData::Item.get(item).is_TM?')
return GameData::Item.get(item).is_TM?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsHiddenMachine?(item)
Deprecation.warn_method('pbIsHiddenMachine?', 'v20', 'GameData::Item.get(item).is_HM?')
return GameData::Item.get(item).is_HM?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsMachine?(item)
Deprecation.warn_method('pbIsMachine?', 'v20', 'GameData::Item.get(item).is_machine?')
return GameData::Item.get(item).is_machine?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsMail?(item)
Deprecation.warn_method('pbIsMail?', 'v20', 'GameData::Item.get(item).is_mail?')
return GameData::Item.get(item).is_mail?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsMailWithPokemonIcons?(item)
Deprecation.warn_method('pbIsMailWithPokemonIcons?', 'v20', 'GameData::Item.get(item).is_icon_mail?')
return GameData::Item.get(item).is_icon_mail?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsPokeBall?(item)
Deprecation.warn_method('pbIsPokeBall?', 'v20', 'GameData::Item.get(item).is_poke_ball?')
return GameData::Item.get(item).is_poke_ball?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsSnagBall?(item)
Deprecation.warn_method('pbIsSnagBall?', 'v20', 'GameData::Item.get(item).is_snag_ball?')
return GameData::Item.get(item).is_snag_ball?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsBerry?(item)
Deprecation.warn_method('pbIsBerry?', 'v20', 'GameData::Item.get(item).is_berry?')
return GameData::Item.get(item).is_berry?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsKeyItem?(item)
Deprecation.warn_method('pbIsKeyItem?', 'v20', 'GameData::Item.get(item).is_key_item?')
return GameData::Item.get(item).is_key_item?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsEvolutionStone?(item)
Deprecation.warn_method('pbIsEvolutionStone?', 'v20', 'GameData::Item.get(item).is_evolution_stone?')
return GameData::Item.get(item).is_evolution_stone?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsFossil?(item)
Deprecation.warn_method('pbIsFossil?', 'v20', 'GameData::Item.get(item).is_fossil?')
return GameData::Item.get(item).is_fossil?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsApricorn?(item)
Deprecation.warn_method('pbIsApricorn?', 'v20', 'GameData::Item.get(item).is_apricorn?')
return GameData::Item.get(item).is_apricorn?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsGem?(item)
Deprecation.warn_method('pbIsGem?', 'v20', 'GameData::Item.get(item).is_gem?')
return GameData::Item.get(item).is_gem?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsMulch?(item)
Deprecation.warn_method('pbIsMulch?', 'v20', 'GameData::Item.get(item).is_mulch?')
return GameData::Item.get(item).is_mulch?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsMegaStone?(item)
Deprecation.warn_method('pbIsMegaStone?', 'v20', 'GameData::Item.get(item).is_mega_stone?')
return GameData::Item.get(item).is_mega_stone?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsImportantItem?(item)
Deprecation.warn_method('pbIsImportantItem?', 'v20', 'GameData::Item.get(item).is_important?')
return GameData::Item.get(item).is_important?
end
# @deprecated This alias is slated to be removed in v20.
def pbCanHoldItem?(item)
Deprecation.warn_method('pbCanHoldItem?', 'v20', 'GameData::Item.get(item).can_hold?')
return GameData::Item.get(item).can_hold?
end
# @deprecated This alias is slated to be removed in v20.
def pbIsUnlosableItem?(check_item, species, ability)
Deprecation.warn_method('pbIsUnlosableItem?', 'v20', 'GameData::Item.get(item).unlosable?')
return GameData::Item.get(check_item).unlosable?(species, ability)
end
# @deprecated This alias is slated to be removed in v20.
def pbItemIconFile(item)
Deprecation.warn_method('pbItemIconFile', 'v20', 'GameData::Item.icon_filename(item)')
return GameData::Item.icon_filename(item)
end
# @deprecated This alias is slated to be removed in v20.
def pbHeldItemIconFile(item)
Deprecation.warn_method('pbHeldItemIconFile', 'v20', 'GameData::Item.held_icon_filename(item)')
return GameData::Item.held_icon_filename(item)
end
# @deprecated This alias is slated to be removed in v20.
def pbMailBackFile(item)
Deprecation.warn_method('pbMailBackFile', 'v20', 'GameData::Item.mail_filename(item)')
return GameData::Item.mail_filename(item)
end

36
Data/Scripts/010_Data/002_PBS data/007_BerryPlant.rb Normal file
View File

@@ -0,0 +1,36 @@
module GameData
class BerryPlant
attr_reader :id
attr_reader :id_number
attr_reader :hours_per_stage
attr_reader :drying_per_hour
attr_reader :minimum_yield
attr_reader :maximum_yield
DATA = {}
DATA_FILENAME = "berry_plants.dat"
NUMBER_OF_REPLANTS = 9
extend ClassMethods
include InstanceMethods
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@hours_per_stage = hash[:hours_per_stage] || 3
@drying_per_hour = hash[:drying_per_hour] || 15
@minimum_yield = hash[:minimum_yield] || 2
@maximum_yield = hash[:maximum_yield] || 5
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetBerryPlantData(item)
Deprecation.warn_method('pbGetBerryPlantData', 'v20', 'GameData::BerryPlant.get(item)')
return GameData::BerryPlant.get(item)
end

398
Data/Scripts/010_Data/002_PBS data/008_Species.rb Normal file
View File

@@ -0,0 +1,398 @@
module GameData
class Species
attr_reader :id
attr_reader :id_number
attr_reader :species
attr_reader :form
attr_reader :real_name
attr_reader :real_form_name
attr_reader :real_category
attr_reader :real_pokedex_entry
attr_reader :pokedex_form
attr_reader :type1
attr_reader :type2
attr_reader :base_stats
attr_reader :evs
attr_reader :base_exp
attr_reader :growth_rate
attr_reader :gender_ratio
attr_reader :catch_rate
attr_reader :happiness
attr_reader :moves
attr_reader :tutor_moves
attr_reader :egg_moves
attr_reader :abilities
attr_reader :hidden_abilities
attr_reader :wild_item_common
attr_reader :wild_item_uncommon
attr_reader :wild_item_rare
attr_reader :egg_groups
attr_reader :hatch_steps
attr_reader :incense
attr_reader :evolutions
attr_reader :height
attr_reader :weight
attr_reader :color
attr_reader :shape
attr_reader :habitat
attr_reader :generation
attr_reader :mega_stone
attr_reader :mega_move
attr_reader :unmega_form
attr_reader :mega_message
attr_accessor :back_sprite_x
attr_accessor :back_sprite_y
attr_accessor :front_sprite_x
attr_accessor :front_sprite_y
attr_accessor :front_sprite_altitude
attr_accessor :shadow_x
attr_accessor :shadow_size
DATA = {}
DATA_FILENAME = "species.dat"
extend ClassMethods
include InstanceMethods
# @param species [Symbol, self, String, Integer]
# @param form [Integer]
# @return [self, nil]
def self.get_species_form(species, form)
return nil if !species || !form
validate species => [Symbol, self, String, Integer]
validate form => Integer
# if other.is_a?(Integer)
# p "Please switch to symbols, thanks."
# end
species = species.species if species.is_a?(self)
species = DATA[species].species if species.is_a?(Integer)
species = species.to_sym if species.is_a?(String)
trial = sprintf("%s_%d", species, form).to_sym
species_form = (DATA[trial].nil?) ? species : trial
return (DATA.has_key?(species_form)) ? DATA[species_form] : nil
end
def self.schema(compiling_forms = false)
ret = {
"FormName" => [0, "q"],
"Kind" => [0, "s"],
"Pokedex" => [0, "q"],
"Type1" => [0, "e", :Type],
"Type2" => [0, "e", :Type],
"BaseStats" => [0, "vvvvvv"],
"EffortPoints" => [0, "uuuuuu"],
"BaseEXP" => [0, "v"],
"Rareness" => [0, "u"],
"Happiness" => [0, "u"],
"Moves" => [0, "*ue", nil, :Move],
"TutorMoves" => [0, "*e", :Move],
"EggMoves" => [0, "*e", :Move],
"Abilities" => [0, "*e", :Ability],
"HiddenAbility" => [0, "*e", :Ability],
"WildItemCommon" => [0, "e", :Item],
"WildItemUncommon" => [0, "e", :Item],
"WildItemRare" => [0, "e", :Item],
"Compatibility" => [0, "*e", :EggGroup],
"StepsToHatch" => [0, "v"],
"Height" => [0, "f"],
"Weight" => [0, "f"],
"Color" => [0, "e", :BodyColor],
"Shape" => [0, "y", :BodyShape],
"Habitat" => [0, "e", :Habitat],
"Generation" => [0, "i"],
"BattlerPlayerX" => [0, "i"],
"BattlerPlayerY" => [0, "i"],
"BattlerEnemyX" => [0, "i"],
"BattlerEnemyY" => [0, "i"],
"BattlerAltitude" => [0, "i"],
"BattlerShadowX" => [0, "i"],
"BattlerShadowSize" => [0, "u"]
}
if compiling_forms
ret["PokedexForm"] = [0, "u"]
ret["Evolutions"] = [0, "*ees", :Species, :Evolution, nil]
ret["MegaStone"] = [0, "e", :Item]
ret["MegaMove"] = [0, "e", :Move]
ret["UnmegaForm"] = [0, "u"]
ret["MegaMessage"] = [0, "u"]
else
ret["InternalName"] = [0, "n"]
ret["Name"] = [0, "s"]
ret["GrowthRate"] = [0, "e", :GrowthRate]
ret["GenderRate"] = [0, "e", :GenderRatio]
ret["Incense"] = [0, "e", :Item]
ret["Evolutions"] = [0, "*ses", nil, :Evolution, nil]
end
return ret
end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@species = hash[:species] || @id
@form = hash[:form] || 0
@real_name = hash[:name] || "Unnamed"
@real_form_name = hash[:form_name]
@real_category = hash[:category] || "???"
@real_pokedex_entry = hash[:pokedex_entry] || "???"
@pokedex_form = hash[:pokedex_form] || @form
@type1 = hash[:type1] || :NORMAL
@type2 = hash[:type2] || @type1
@base_stats = hash[:base_stats] || {}
@evs = hash[:evs] || {}
GameData::Stat.each_main do |s|
@base_stats[s.id] = 1 if !@base_stats[s.id] || @base_stats[s.id] <= 0
@evs[s.id] = 0 if !@evs[s.id] || @evs[s.id] < 0
end
@base_exp = hash[:base_exp] || 100
@growth_rate = hash[:growth_rate] || :Medium
@gender_ratio = hash[:gender_ratio] || :Female50Percent
@catch_rate = hash[:catch_rate] || 255
@happiness = hash[:happiness] || 70
@moves = hash[:moves] || []
@tutor_moves = hash[:tutor_moves] || []
@egg_moves = hash[:egg_moves] || []
@abilities = hash[:abilities] || []
@hidden_abilities = hash[:hidden_abilities] || []
@wild_item_common = hash[:wild_item_common]
@wild_item_uncommon = hash[:wild_item_uncommon]
@wild_item_rare = hash[:wild_item_rare]
@egg_groups = hash[:egg_groups] || [:Undiscovered]
@hatch_steps = hash[:hatch_steps] || 1
@incense = hash[:incense]
@evolutions = hash[:evolutions] || []
@height = hash[:height] || 1
@weight = hash[:weight] || 1
@color = hash[:color] || :Red
@shape = hash[:shape] || :Body
@habitat = hash[:habitat] || :None
@generation = hash[:generation] || 0
@mega_stone = hash[:mega_stone]
@mega_move = hash[:mega_move]
@unmega_form = hash[:unmega_form] || 0
@mega_message = hash[:mega_message] || 0
@back_sprite_x = hash[:back_sprite_x] || 0
@back_sprite_y = hash[:back_sprite_y] || 0
@front_sprite_x = hash[:front_sprite_x] || 0
@front_sprite_y = hash[:front_sprite_y] || 0
@front_sprite_altitude = hash[:front_sprite_altitude] || 0
@shadow_x = hash[:shadow_x] || 0
@shadow_size = hash[:shadow_size] || 2
end
# @return [String] the translated name of this species
def name
return pbGetMessage(MessageTypes::Species, @id_number)
end
# @return [String] the translated name of this form of this species
def form_name
return pbGetMessage(MessageTypes::FormNames, @id_number)
end
# @return [String] the translated Pokédex category of this species
def category
return pbGetMessage(MessageTypes::Kinds, @id_number)
end
# @return [String] the translated Pokédex entry of this species
def pokedex_entry
return pbGetMessage(MessageTypes::Entries, @id_number)
end
def apply_metrics_to_sprite(sprite, index, shadow = false)
if shadow
if (index & 1) == 1 # Foe Pokémon
sprite.x += @shadow_x * 2
end
else
if (index & 1) == 0 # Player's Pokémon
sprite.x += @back_sprite_x * 2
sprite.y += @back_sprite_y * 2
else # Foe Pokémon
sprite.x += @front_sprite_x * 2
sprite.y += @front_sprite_y * 2
sprite.y -= @front_sprite_altitude * 2
end
end
end
def shows_shadow?
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
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetSpeciesData(species, form = 0, species_data_type = -1)
Deprecation.warn_method('pbGetSpeciesData', 'v20', 'GameData::Species.get_species_form(species, form).something')
return GameData::Species.get_species_form(species, form)
end
# @deprecated This alias is slated to be removed in v20.
def pbGetSpeciesEggMoves(species, form = 0)
Deprecation.warn_method('pbGetSpeciesEggMoves', 'v20', 'GameData::Species.get_species_form(species, form).egg_moves')
return GameData::Species.get_species_form(species, form).egg_moves
end
# @deprecated This alias is slated to be removed in v20.
def pbGetSpeciesMoveset(species, form = 0)
Deprecation.warn_method('pbGetSpeciesMoveset', 'v20', 'GameData::Species.get_species_form(species, form).moves')
return GameData::Species.get_species_form(species, form).moves
end
# @deprecated This alias is slated to be removed in v20.
def pbGetEvolutionData(species)
Deprecation.warn_method('pbGetEvolutionData', 'v20', 'GameData::Species.get(species).evolutions')
return GameData::Species.get(species).evolutions
end
# @deprecated This alias is slated to be removed in v20.
def pbApplyBattlerMetricsToSprite(sprite, index, species_data, shadow = false, metrics = nil)
Deprecation.warn_method('pbApplyBattlerMetricsToSprite', 'v20', 'GameData::Species.get(species).apply_metrics_to_sprite')
GameData::Species.get(species).apply_metrics_to_sprite(sprite, index, shadow)
end
# @deprecated This alias is slated to be removed in v20.
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

319
Data/Scripts/010_Data/002_PBS data/009_Species_Files.rb Normal file
View File

@@ -0,0 +1,319 @@
module GameData
class Species
def self.check_graphic_file(path, species, form = 0, gender = 0, shiny = false, shadow = false, subfolder = "")
try_subfolder = sprintf("%s/", subfolder)
try_species = species
try_form = (form > 0) ? sprintf("_%d", form) : ""
try_gender = (gender == 1) ? "_female" : ""
try_shadow = (shadow) ? "_shadow" : ""
factors = []
factors.push([4, sprintf("%s shiny/", subfolder), try_subfolder]) if shiny
factors.push([3, try_shadow, ""]) if shadow
factors.push([2, try_gender, ""]) if gender == 1
factors.push([1, try_form, ""]) if form > 0
factors.push([0, try_species, "000"])
# Go through each combination of parameters in turn to find an existing sprite
for i in 0...2 ** factors.length
# Set try_ parameters for this combination
factors.each_with_index do |factor, index|
value = ((i / (2 ** index)) % 2 == 0) ? factor[1] : factor[2]
case factor[0]
when 0 then try_species = value
when 1 then try_form = value
when 2 then try_gender = value
when 3 then try_shadow = value
when 4 then try_subfolder = value # Shininess
end
end
# Look for a graphic matching this combination's parameters
try_species_text = try_species
ret = pbResolveBitmap(sprintf("%s%s%s%s%s%s", path, try_subfolder,
try_species_text, try_form, try_gender, try_shadow))
return ret if ret
end
return nil
end
def self.check_egg_graphic_file(path, species, form, suffix = "")
species_data = self.get_species_form(species, form)
return nil if species_data.nil?
if form > 0
ret = pbResolveBitmap(sprintf("%s%s_%d%s", path, species_data.species, form, suffix))
return ret if ret
end
return pbResolveBitmap(sprintf("%s%s%s", path, species_data.species, suffix))
end
def self.front_sprite_filename(species, form = 0, gender = 0, shiny = false, shadow = false)
return self.check_graphic_file("Graphics/Pokemon/", species, form, gender, shiny, shadow, "Front")
end
def self.back_sprite_filename(species, form = 0, gender = 0, shiny = false, shadow = false)
return self.check_graphic_file("Graphics/Pokemon/", species, form, gender, shiny, shadow, "Back")
end
def self.egg_sprite_filename(species, form)
ret = self.check_egg_graphic_file("Graphics/Pokemon/Eggs/", species, form)
return (ret) ? ret : pbResolveBitmap("Graphics/Pokemon/Eggs/000")
end
def self.sprite_filename(species, form = 0, gender = 0, shiny = false, shadow = false, back = false, egg = false)
return self.egg_sprite_filename(species, form) if egg
return self.back_sprite_filename(species, form, gender, shiny, shadow) if back
return self.front_sprite_filename(species, form, gender, shiny, shadow)
end
def self.front_sprite_bitmap(species, form = 0, gender = 0, shiny = false, shadow = false)
filename = self.front_sprite_filename(species, form, gender, shiny, shadow)
return (filename) ? AnimatedBitmap.new(filename) : nil
end
def self.back_sprite_bitmap(species, form = 0, gender = 0, shiny = false, shadow = false)
filename = self.back_sprite_filename(species, form, gender, shiny, shadow)
return (filename) ? AnimatedBitmap.new(filename) : nil
end
def self.egg_sprite_bitmap(species, form = 0)
filename = self.egg_sprite_filename(species, form)
return (filename) ? AnimatedBitmap.new(filename) : nil
end
def self.sprite_bitmap(species, form = 0, gender = 0, shiny = false, shadow = false, back = false, egg = false)
return self.egg_sprite_bitmap(species, form) if egg
return self.back_sprite_bitmap(species, form, gender, shiny, shadow) if back
return self.front_sprite_bitmap(species, form, gender, shiny, shadow)
end
def self.sprite_bitmap_from_pokemon(pkmn, back = false, species = nil)
species = pkmn.species if !species
species = GameData::Species.get(species).species # Just to be sure it's a symbol
return self.egg_sprite_bitmap(species, pkmn.form) if pkmn.egg?
if back
ret = self.back_sprite_bitmap(species, pkmn.form, pkmn.gender, pkmn.shiny?, pkmn.shadowPokemon?)
else
ret = self.front_sprite_bitmap(species, pkmn.form, pkmn.gender, pkmn.shiny?, pkmn.shadowPokemon?)
end
alter_bitmap_function = MultipleForms.getFunction(species, "alterBitmap")
if ret && alter_bitmap_function
new_ret = ret.copy
ret.dispose
new_ret.each { |bitmap| alter_bitmap_function.call(pkmn, bitmap) }
ret = new_ret
end
return ret
end
#===========================================================================
def self.egg_icon_filename(species, form)
ret = self.check_egg_graphic_file("Graphics/Pokemon/Eggs/", species, form, "_icon")
return (ret) ? ret : pbResolveBitmap("Graphics/Pokemon/Eggs/000_icon")
end
def self.icon_filename(species, form = 0, gender = 0, shiny = false, shadow = false, egg = false)
return self.egg_icon_filename(species, form) if egg
return self.check_graphic_file("Graphics/Pokemon/", species, form, gender, shiny, shadow, "Icons")
end
def self.icon_filename_from_pokemon(pkmn)
return self.icon_filename(pkmn.species, pkmn.form, pkmn.gender, pkmn.shiny?, pkmn.shadowPokemon?, pkmn.egg?)
end
def self.egg_icon_bitmap(species, form)
filename = self.egg_icon_filename(species, form)
return (filename) ? AnimatedBitmap.new(filename).deanimate : nil
end
def self.icon_bitmap(species, form = 0, gender = 0, shiny = false, shadow = false)
filename = self.icon_filename(species, form, gender,shiny, shadow)
return (filename) ? AnimatedBitmap.new(filename).deanimate : nil
end
def self.icon_bitmap_from_pokemon(pkmn)
return self.icon_bitmap(pkmn.species, pkmn.form, pkmn.gender, pkmn.shiny?, pkmn.shadowPokemon?, pkmn.egg?)
end
#===========================================================================
def self.footprint_filename(species, form = 0)
species_data = self.get_species_form(species, form)
return nil if species_data.nil?
if form > 0
ret = pbResolveBitmap(sprintf("Graphics/Pokemon/Footprints/%s_%d", species_data.species, form))
return ret if ret
end
return pbResolveBitmap(sprintf("Graphics/Pokemon/Footprints/%s", species_data.species))
end
#===========================================================================
def self.shadow_filename(species, form = 0)
species_data = self.get_species_form(species, form)
return nil if species_data.nil?
# Look for species-specific shadow graphic
if form > 0
ret = pbResolveBitmap(sprintf("Graphics/Pokemon/Shadow/%s_%d", species_data.species, form))
return ret if ret
end
ret = pbResolveBitmap(sprintf("Graphics/Pokemon/Shadow/%s", species_data.species))
return ret if ret
# Use general shadow graphic
return pbResolveBitmap(sprintf("Graphics/Pokemon/Shadow/%d", species_data.shadow_size))
end
def self.shadow_bitmap(species, form = 0)
filename = self.shadow_filename(species, form)
return (filename) ? AnimatedBitmap.new(filename) : nil
end
def self.shadow_bitmap_from_pokemon(pkmn)
filename = self.shadow_filename(pkmn.species, pkmn.form)
return (filename) ? AnimatedBitmap.new(filename) : nil
end
#===========================================================================
def self.check_cry_file(species, form)
species_data = self.get_species_form(species, form)
return nil if species_data.nil?
if form > 0
ret = sprintf("Cries/%s_%d", species_data.species, form)
return ret if pbResolveAudioSE(ret)
end
ret = sprintf("Cries/%s", species_data.species)
return (pbResolveAudioSE(ret)) ? ret : nil
end
def self.cry_filename(species, form = 0)
return self.check_cry_file(species, form)
end
def self.cry_filename_from_pokemon(pkmn)
return self.check_cry_file(pkmn.species, pkmn.form)
end
def self.play_cry_from_species(species, form = 0, volume = 90, pitch = 100)
filename = self.cry_filename(species, form)
return if !filename
pbSEPlay(RPG::AudioFile.new(filename, volume, pitch)) rescue nil
end
def self.play_cry_from_pokemon(pkmn, volume = 90, pitch = nil)
return if !pkmn || pkmn.egg?
filename = self.cry_filename_from_pokemon(pkmn)
return if !filename
pitch ||= 75 + (pkmn.hp * 25 / pkmn.totalhp)
pbSEPlay(RPG::AudioFile.new(filename, volume, pitch)) rescue nil
end
def self.play_cry(pkmn, volume = 90, pitch = nil)
if pkmn.is_a?(Pokemon)
self.play_cry_from_pokemon(pkmn, volume, pitch)
else
self.play_cry_from_species(pkmn, nil, volume, pitch)
end
end
def self.cry_length(species, form = 0, pitch = 100)
return 0 if !species || pitch <= 0
pitch = pitch.to_f / 100
ret = 0.0
if species.is_a?(Pokemon)
if !species.egg?
filename = pbResolveAudioSE(GameData::Species.cry_filename_from_pokemon(species))
ret = getPlayTime(filename) if filename
end
else
filename = pbResolveAudioSE(GameData::Species.cry_filename(species, form))
ret = getPlayTime(filename) if filename
end
ret /= pitch # Sound played at a lower pitch lasts longer
return (ret * Graphics.frame_rate).ceil + 4 # 4 provides a buffer between sounds
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbLoadSpeciesBitmap(species, gender = 0, form = 0, shiny = false, shadow = false, back = false , egg = false)
Deprecation.warn_method('pbLoadSpeciesBitmap', 'v20', 'GameData::Species.sprite_bitmap(species, form, gender, shiny, shadow, back, egg)')
return GameData::Species.sprite_bitmap(species, form, gender, shiny, shadow, back, egg)
end
# @deprecated This alias is slated to be removed in v20.
def pbLoadPokemonBitmap(pkmn, back = false)
Deprecation.warn_method('pbLoadPokemonBitmap', 'v20', 'GameData::Species.sprite_bitmap_from_pokemon(pkmn)')
return GameData::Species.sprite_bitmap_from_pokemon(pkmn, back)
end
# @deprecated This alias is slated to be removed in v20.
def pbLoadPokemonBitmapSpecies(pkmn, species, back = false)
Deprecation.warn_method('pbLoadPokemonBitmapSpecies', 'v20', 'GameData::Species.sprite_bitmap_from_pokemon(pkmn, back, species)')
return GameData::Species.sprite_bitmap_from_pokemon(pkmn, back, species)
end
# @deprecated This alias is slated to be removed in v20.
def pbPokemonIconFile(pkmn)
Deprecation.warn_method('pbPokemonIconFile', 'v20', 'GameData::Species.icon_filename_from_pokemon(pkmn)')
return GameData::Species.icon_filename_from_pokemon(pkmn)
end
# @deprecated This alias is slated to be removed in v20.
def pbLoadPokemonIcon(pkmn)
Deprecation.warn_method('pbLoadPokemonIcon', 'v20', 'GameData::Species.icon_bitmap_from_pokemon(pkmn)')
return GameData::Species.icon_bitmap_from_pokemon(pkmn)
end
# @deprecated This alias is slated to be removed in v20.
def pbPokemonFootprintFile(species, form = 0)
Deprecation.warn_method('pbPokemonFootprintFile', 'v20', 'GameData::Species.footprint_filename(species, form)')
return GameData::Species.footprint_filename(species, form)
end
# @deprecated This alias is slated to be removed in v20.
def pbCheckPokemonShadowBitmapFiles(species, form = 0)
Deprecation.warn_method('pbCheckPokemonShadowBitmapFiles', 'v20', 'GameData::Species.shadow_filename(species, form)')
return GameData::Species.shadow_filename(species, form)
end
# @deprecated This alias is slated to be removed in v20.
def pbLoadPokemonShadowBitmap(pkmn)
Deprecation.warn_method('pbLoadPokemonShadowBitmap', 'v20', 'GameData::Species.shadow_bitmap_from_pokemon(pkmn)')
return GameData::Species.shadow_bitmap_from_pokemon(pkmn)
end
# @deprecated This alias is slated to be removed in v20.
def pbCryFile(species, form = 0)
if species.is_a?(Pokemon)
Deprecation.warn_method('pbCryFile', 'v20', 'GameData::Species.cry_filename_from_pokemon(pkmn)')
return GameData::Species.cry_filename_from_pokemon(species)
end
Deprecation.warn_method('pbCryFile', 'v20', 'GameData::Species.cry_filename(species, form)')
return GameData::Species.cry_filename(species, form)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayCry(pkmn, volume = 90, pitch = nil)
Deprecation.warn_method('pbPlayCry', 'v20', 'GameData::Species.play_cry(pkmn)')
GameData::Species.play_cry(pkmn, volume, pitch)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayCrySpecies(species, form = 0, volume = 90, pitch = nil)
Deprecation.warn_method('pbPlayCrySpecies', 'v20', 'GameData::Species.play_cry_from_species(species, form)')
GameData::Species.play_cry_from_species(species, form, volume, pitch)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayCryPokemon(pkmn, volume = 90, pitch = nil)
Deprecation.warn_method('pbPlayCryPokemon', 'v20', 'GameData::Species.play_cry_from_pokemon(pkmn)')
GameData::Species.play_cry_from_pokemon(pkmn, volume, pitch)
end
# @deprecated This alias is slated to be removed in v20.
def pbCryFrameLength(species, form = 0, pitch = 100)
Deprecation.warn_method('pbCryFrameLength', 'v20', 'GameData::Species.cry_length(species, form)')
return GameData::Species.cry_length(species, form, pitch)
end

31
Data/Scripts/010_Data/002_PBS data/010_Ribbon.rb Normal file
View File

@@ -0,0 +1,31 @@
module GameData
class Ribbon
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :real_description
DATA = {}
DATA_FILENAME = "ribbons.dat"
extend ClassMethods
include InstanceMethods
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@real_description = hash[:description] || "???"
end
# @return [String] the translated name of this ribbon
def name
return pbGetMessage(MessageTypes::RibbonNames, @id_number)
end
# @return [String] the translated description of this ribbon
def description
return pbGetMessage(MessageTypes::RibbonDescriptions, @id_number)
end
end
end

77
Data/Scripts/010_Data/002_PBS data/011_Encounter.rb Normal file
View File

@@ -0,0 +1,77 @@
module GameData
class Encounter
attr_accessor :id
attr_accessor :map
attr_accessor :version
attr_reader :step_chances
attr_reader :types
DATA = {}
DATA_FILENAME = "encounters.dat"
extend ClassMethods
include InstanceMethods
# @param map_id [Integer]
# @param map_version [Integer, nil]
# @return [Boolean] whether there is encounter data for the given map ID/version
def self.exists?(map_id, map_version = 0)
validate map_id => [Integer]
validate map_version => [Integer]
key = sprintf("%s_%d", map_id, map_version).to_sym
return !self::DATA[key].nil?
end
# @param map_id [Integer]
# @param map_version [Integer, nil]
# @return [self, nil]
def self.get(map_id, map_version = 0)
validate map_id => Integer
validate map_version => Integer
trial_key = sprintf("%s_%d", map_id, map_version).to_sym
key = (self::DATA.has_key?(trial_key)) ? trial_key : sprintf("%s_0", map_id).to_sym
return self::DATA[key]
end
# Yields all encounter data in order of their map and version numbers.
def self.each
keys = self::DATA.keys.sort do |a, b|
if self::DATA[a].map == self::DATA[b].map
self::DATA[a].version <=> self::DATA[b].version
else
self::DATA[a].map <=> self::DATA[b].map
end
end
keys.each { |key| yield self::DATA[key] }
end
# Yields all encounter data for the given version. Also yields encounter
# data for version 0 of a map if that map doesn't have encounter data for
# the given version.
def self.each_of_version(version = 0)
self.each do |data|
yield data if data.version == version
if version > 0
yield data if data.version == 0 && !self::DATA.has_key?([data.map, version])
end
end
end
def initialize(hash)
@id = hash[:id]
@map = hash[:map]
@version = hash[:version] || 0
@step_chances = hash[:step_chances]
@types = hash[:types] || {}
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbLoadEncountersData
Deprecation.warn_method('pbLoadEncountersData', 'v20', 'GameData::Encounter.get(map_id, version)')
return nil
end

147
Data/Scripts/010_Data/002_PBS data/012_TrainerType.rb Normal file
View File

@@ -0,0 +1,147 @@
module GameData
class TrainerType
attr_reader :id
attr_reader :id_number
attr_reader :real_name
attr_reader :base_money
attr_reader :battle_BGM
attr_reader :victory_ME
attr_reader :intro_ME
attr_reader :gender
attr_reader :skill_level
attr_reader :skill_code
DATA = {}
DATA_FILENAME = "trainer_types.dat"
extend ClassMethods
include InstanceMethods
def self.check_file(tr_type, path, optional_suffix = "", suffix = "")
tr_type_data = self.try_get(tr_type)
return nil if tr_type_data.nil?
# Check for files
if !optional_suffix.empty?
ret = path + tr_type_data.id.to_s + optional_suffix + suffix
return ret if pbResolveBitmap(ret)
end
ret = path + tr_type_data.id.to_s + suffix
return (pbResolveBitmap(ret)) ? ret : nil
end
def self.charset_filename(tr_type)
return self.check_file(tr_type, "Graphics/Characters/trchar")
end
def self.charset_filename_brief(tr_type)
ret = self.charset_filename(tr_type)
ret.slice!("Graphics/Characters/") if ret
return ret
end
def self.front_sprite_filename(tr_type)
return self.check_file(tr_type, "Graphics/Trainers/")
end
def self.player_front_sprite_filename(tr_type)
outfit = ($Trainer) ? $Trainer.outfit : 0
return self.check_file(tr_type, "Graphics/Trainers/", sprintf("_%d", outfit))
end
def self.back_sprite_filename(tr_type)
return self.check_file(tr_type, "Graphics/Trainers/", nil, "_back")
end
def self.player_back_sprite_filename(tr_type)
outfit = ($Trainer) ? $Trainer.outfit : 0
return self.check_file(tr_type, "Graphics/Trainers/", sprintf("_%d", outfit), "_back")
end
def self.map_icon_filename(tr_type)
return self.check_file(tr_type, "Graphics/Pictures/mapPlayer")
end
def self.player_map_icon_filename(tr_type)
outfit = ($Trainer) ? $Trainer.outfit : 0
return self.check_file(tr_type, "Graphics/Pictures/mapPlayer", sprintf("_%d", outfit))
end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number] || -1
@real_name = hash[:name] || "Unnamed"
@base_money = hash[:base_money] || 30
@battle_BGM = hash[:battle_BGM]
@victory_ME = hash[:victory_ME]
@intro_ME = hash[:intro_ME]
@gender = hash[:gender] || 2
@skill_level = hash[:skill_level] || @base_money
@skill_code = hash[:skill_code]
end
# @return [String] the translated name of this trainer type
def name
return pbGetMessage(MessageTypes::TrainerTypes, @id_number)
end
def male?; return @gender == 0; end
def female?; return @gender == 1; end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetTrainerTypeData(tr_type)
Deprecation.warn_method('pbGetTrainerTypeData', 'v20', 'GameData::TrainerType.get(trainer_type)')
return GameData::TrainerType.get(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbTrainerCharFile(tr_type) # Used by the phone
Deprecation.warn_method('pbTrainerCharFile', 'v20', 'GameData::TrainerType.charset_filename(trainer_type)')
return GameData::TrainerType.charset_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbTrainerCharNameFile(tr_type) # Used by Battle Frontier and compiler
Deprecation.warn_method('pbTrainerCharNameFile', 'v20', 'GameData::TrainerType.charset_filename_brief(trainer_type)')
return GameData::TrainerType.charset_filename_brief(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbTrainerSpriteFile(tr_type)
Deprecation.warn_method('pbTrainerSpriteFile', 'v20', 'GameData::TrainerType.front_sprite_filename(trainer_type)')
return GameData::TrainerType.front_sprite_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbTrainerSpriteBackFile(tr_type)
Deprecation.warn_method('pbTrainerSpriteBackFile', 'v20', 'GameData::TrainerType.back_sprite_filename(trainer_type)')
return GameData::TrainerType.back_sprite_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayerSpriteFile(tr_type)
Deprecation.warn_method('pbPlayerSpriteFile', 'v20', 'GameData::TrainerType.player_front_sprite_filename(trainer_type)')
return GameData::TrainerType.player_front_sprite_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayerSpriteBackFile(tr_type)
Deprecation.warn_method('pbPlayerSpriteBackFile', 'v20', 'GameData::TrainerType.player_back_sprite_filename(trainer_type)')
return GameData::TrainerType.player_back_sprite_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbTrainerHeadFile(tr_type)
Deprecation.warn_method('pbTrainerHeadFile', 'v20', 'GameData::TrainerType.map_icon_filename(trainer_type)')
return GameData::TrainerType.map_icon_filename(tr_type)
end
# @deprecated This alias is slated to be removed in v20.
def pbPlayerHeadFile(tr_type)
Deprecation.warn_method('pbPlayerHeadFile', 'v20', 'GameData::TrainerType.player_map_icon_filename(trainer_type)')
return GameData::TrainerType.player_map_icon_filename(tr_type)
end

173
Data/Scripts/010_Data/002_PBS data/013_Trainer.rb Normal file
View File

@@ -0,0 +1,173 @@
module GameData
class Trainer
attr_reader :id
attr_reader :id_number
attr_reader :trainer_type
attr_reader :real_name
attr_reader :version
attr_reader :items
attr_reader :real_lose_text
attr_reader :pokemon
DATA = {}
DATA_FILENAME = "trainers.dat"
SCHEMA = {
"Items" => [:items, "*e", :Item],
"LoseText" => [:lose_text, "s"],
"Pokemon" => [:pokemon, "ev", :Species], # Species, level
"Form" => [:form, "u"],
"Name" => [:name, "s"],
"Moves" => [:moves, "*e", :Move],
"Ability" => [:ability_flag, "u"],
"Item" => [:item, "e", :Item],
"Gender" => [:gender, "e", { "M" => 0, "m" => 0, "Male" => 0, "male" => 0, "0" => 0,
"F" => 1, "f" => 1, "Female" => 1, "female" => 1, "1" => 1 }],
"Nature" => [:nature, "e", :Nature],
"IV" => [:iv, "uUUUUU"],
"EV" => [:ev, "uUUUUU"],
"Happiness" => [:happiness, "u"],
"Shiny" => [:shininess, "b"],
"Shadow" => [:shadowness, "b"],
"Ball" => [:poke_ball, "u"],
}
extend ClassMethods
include InstanceMethods
# @param tr_type [Symbol, String]
# @param tr_name [String]
# @param tr_version [Integer, nil]
# @return [Boolean] whether the given other is defined as a self
def self.exists?(tr_type, tr_name, tr_version = 0)
validate tr_type => [Symbol, String]
validate tr_name => [String]
key = [tr_type.to_sym, tr_name, tr_version]
return !self::DATA[key].nil?
end
# @param tr_type [Symbol, String]
# @param tr_name [String]
# @param tr_version [Integer, nil]
# @return [self]
def self.get(tr_type, tr_name, tr_version = 0)
validate tr_type => [Symbol, String]
validate tr_name => [String]
key = [tr_type.to_sym, tr_name, tr_version]
raise "Unknown trainer #{tr_type} #{tr_name} #{tr_version}." unless self::DATA.has_key?(key)
return self::DATA[key]
end
# @param tr_type [Symbol, String]
# @param tr_name [String]
# @param tr_version [Integer, nil]
# @return [self, nil]
def self.try_get(tr_type, tr_name, tr_version = 0)
validate tr_type => [Symbol, String]
validate tr_name => [String]
key = [tr_type.to_sym, tr_name, tr_version]
return (self::DATA.has_key?(key)) ? self::DATA[key] : nil
end
def initialize(hash)
@id = hash[:id]
@id_number = hash[:id_number]
@trainer_type = hash[:trainer_type]
@real_name = hash[:name] || "Unnamed"
@version = hash[:version] || 0
@items = hash[:items] || []
@real_lose_text = hash[:lose_text] || "..."
@pokemon = hash[:pokemon] || []
@pokemon.each do |pkmn|
GameData::Stat.each_main do |s|
pkmn[:iv][s.id] ||= 0 if pkmn[:iv]
pkmn[:ev][s.id] ||= 0 if pkmn[:ev]
end
end
end
# @return [String] the translated name of this trainer
def name
return pbGetMessageFromHash(MessageTypes::TrainerNames, @real_name)
end
# @return [String] the translated in-battle lose message of this trainer
def lose_text
return pbGetMessageFromHash(MessageTypes::TrainerLoseText, @real_lose_text)
end
# Creates a battle-ready version of a trainer's data.
# @return [Array] all information about a trainer in a usable form
def to_trainer
# Determine trainer's name
tr_name = self.name
Settings::RIVAL_NAMES.each do |rival|
next if rival[0] != @trainer_type || !$game_variables[rival[1]].is_a?(String)
tr_name = $game_variables[rival[1]]
break
end
# Create trainer object
trainer = NPCTrainer.new(tr_name, @trainer_type)
trainer.id = $Trainer.make_foreign_ID
trainer.items = @items.clone
trainer.lose_text = self.lose_text
# Create each Pokémon owned by the trainer
@pokemon.each do |pkmn_data|
species = GameData::Species.get(pkmn_data[:species]).species
pkmn = Pokemon.new(species, pkmn_data[:level], trainer, false)
trainer.party.push(pkmn)
# Set Pokémon's properties if defined
if pkmn_data[:form]
pkmn.forced_form = pkmn_data[:form] if MultipleForms.hasFunction?(species, "getForm")
pkmn.form_simple = pkmn_data[:form]
end
pkmn.item = pkmn_data[:item]
if pkmn_data[:moves] && pkmn_data[:moves].length > 0
pkmn_data[:moves].each { |move| pkmn.learn_move(move) }
else
pkmn.reset_moves
end
pkmn.ability_index = pkmn_data[:ability_flag]
pkmn.gender = pkmn_data[:gender] || ((trainer.male?) ? 0 : 1)
pkmn.shiny = (pkmn_data[:shininess]) ? true : false
if pkmn_data[:nature]
pkmn.nature = pkmn_data[:nature]
else
nature = pkmn.species_data.id_number + GameData::TrainerType.get(trainer.trainer_type).id_number
pkmn.nature = nature % (GameData::Nature::DATA.length / 2)
end
GameData::Stat.each_main do |s|
if pkmn_data[:iv]
pkmn.iv[s.id] = pkmn_data[:iv][s.id]
else
pkmn.iv[s.id] = [pkmn_data[:level] / 2, Pokemon::IV_STAT_LIMIT].min
end
if pkmn_data[:ev]
pkmn.ev[s.id] = pkmn_data[:ev][s.id]
else
pkmn.ev[s.id] = [pkmn_data[:level] * 3 / 2, Pokemon::EV_LIMIT / 6].min
end
end
pkmn.happiness = pkmn_data[:happiness] if pkmn_data[:happiness]
pkmn.name = pkmn_data[:name] if pkmn_data[:name] && !pkmn_data[:name].empty?
if pkmn_data[:shadowness]
pkmn.makeShadow
pkmn.update_shadow_moves(true)
pkmn.shiny = false
end
pkmn.poke_ball = pbBallTypeToItem(pkmn_data[:poke_ball]).id if pkmn_data[:poke_ball]
pkmn.calc_stats
end
return trainer
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbGetTrainerData(tr_type, tr_name, tr_version = 0)
Deprecation.warn_method('pbGetTrainerData', 'v20', 'GameData::Trainer.get(tr_type, tr_name, tr_version)')
return GameData::Trainer.get(tr_type, tr_name, tr_version)
end

146
Data/Scripts/010_Data/002_PBS data/014_Metadata.rb Normal file
View File

@@ -0,0 +1,146 @@
module GameData
class Metadata
attr_reader :id
attr_reader :home
attr_reader :wild_battle_BGM
attr_reader :trainer_battle_BGM
attr_reader :wild_victory_ME
attr_reader :trainer_victory_ME
attr_reader :wild_capture_ME
attr_reader :surf_BGM
attr_reader :bicycle_BGM
attr_reader :player_A
attr_reader :player_B
attr_reader :player_C
attr_reader :player_D
attr_reader :player_E
attr_reader :player_F
attr_reader :player_G
attr_reader :player_H
DATA = {}
DATA_FILENAME = "metadata.dat"
SCHEMA = {
"Home" => [1, "vuuu"],
"WildBattleBGM" => [2, "s"],
"TrainerBattleBGM" => [3, "s"],
"WildVictoryME" => [4, "s"],
"TrainerVictoryME" => [5, "s"],
"WildCaptureME" => [6, "s"],
"SurfBGM" => [7, "s"],
"BicycleBGM" => [8, "s"],
"PlayerA" => [9, "esssssss", :TrainerType],
"PlayerB" => [10, "esssssss", :TrainerType],
"PlayerC" => [11, "esssssss", :TrainerType],
"PlayerD" => [12, "esssssss", :TrainerType],
"PlayerE" => [13, "esssssss", :TrainerType],
"PlayerF" => [14, "esssssss", :TrainerType],
"PlayerG" => [15, "esssssss", :TrainerType],
"PlayerH" => [16, "esssssss", :TrainerType]
}
extend ClassMethodsIDNumbers
include InstanceMethods
def self.editor_properties
return [
["Home", MapCoordsFacingProperty, _INTL("Map ID and X and Y coordinates of where the player goes if no Pokémon Center was entered after a loss.")],
["WildBattleBGM", BGMProperty, _INTL("Default BGM for wild Pokémon battles.")],
["TrainerBattleBGM", BGMProperty, _INTL("Default BGM for Trainer battles.")],
["WildVictoryME", MEProperty, _INTL("Default ME played after winning a wild Pokémon battle.")],
["TrainerVictoryME", MEProperty, _INTL("Default ME played after winning a Trainer battle.")],
["WildCaptureME", MEProperty, _INTL("Default ME played after catching a Pokémon.")],
["SurfBGM", BGMProperty, _INTL("BGM played while surfing.")],
["BicycleBGM", BGMProperty, _INTL("BGM played while on a bicycle.")],
["PlayerA", PlayerProperty, _INTL("Specifies player A.")],
["PlayerB", PlayerProperty, _INTL("Specifies player B.")],
["PlayerC", PlayerProperty, _INTL("Specifies player C.")],
["PlayerD", PlayerProperty, _INTL("Specifies player D.")],
["PlayerE", PlayerProperty, _INTL("Specifies player E.")],
["PlayerF", PlayerProperty, _INTL("Specifies player F.")],
["PlayerG", PlayerProperty, _INTL("Specifies player G.")],
["PlayerH", PlayerProperty, _INTL("Specifies player H.")]
]
end
def self.get
return DATA[0]
end
def self.get_player(id)
case id
when 0 then return self.get.player_A
when 1 then return self.get.player_B
when 2 then return self.get.player_C
when 3 then return self.get.player_D
when 4 then return self.get.player_E
when 5 then return self.get.player_F
when 6 then return self.get.player_G
when 7 then return self.get.player_H
end
return nil
end
def initialize(hash)
@id = hash[:id]
@home = hash[:home]
@wild_battle_BGM = hash[:wild_battle_BGM]
@trainer_battle_BGM = hash[:trainer_battle_BGM]
@wild_victory_ME = hash[:wild_victory_ME]
@trainer_victory_ME = hash[:trainer_victory_ME]
@wild_capture_ME = hash[:wild_capture_ME]
@surf_BGM = hash[:surf_BGM]
@bicycle_BGM = hash[:bicycle_BGM]
@player_A = hash[:player_A]
@player_B = hash[:player_B]
@player_C = hash[:player_C]
@player_D = hash[:player_D]
@player_E = hash[:player_E]
@player_F = hash[:player_F]
@player_G = hash[:player_G]
@player_H = hash[:player_H]
end
def property_from_string(str)
case str
when "Home" then return @home
when "WildBattleBGM" then return @wild_battle_BGM
when "TrainerBattleBGM" then return @trainer_battle_BGM
when "WildVictoryME" then return @wild_victory_ME
when "TrainerVictoryME" then return @trainer_victory_ME
when "WildCaptureME" then return @wild_capture_ME
when "SurfBGM" then return @surf_BGM
when "BicycleBGM" then return @bicycle_BGM
when "PlayerA" then return @player_A
when "PlayerB" then return @player_B
when "PlayerC" then return @player_C
when "PlayerD" then return @player_D
when "PlayerE" then return @player_E
when "PlayerF" then return @player_F
when "PlayerG" then return @player_G
when "PlayerH" then return @player_H
end
return nil
end
end
end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This alias is slated to be removed in v20.
def pbLoadMetadata
Deprecation.warn_method('pbLoadMetadata', 'v20', 'GameData::Metadata.get or GameData::MapMetadata.get(map_id)')
return nil
end
# @deprecated This alias is slated to be removed in v20.
def pbGetMetadata(map_id, metadata_type)
if map_id == 0 # Global metadata
Deprecation.warn_method('pbGetMetadata', 'v20', 'GameData::Metadata.get.something')
else # Map metadata
Deprecation.warn_method('pbGetMetadata', 'v20', 'GameData::MapMetadata.get(map_id).something')
end
return nil
end

129
Data/Scripts/010_Data/002_PBS data/015_MapMetadata.rb Normal file
View File

@@ -0,0 +1,129 @@
module GameData
class MapMetadata
attr_reader :id
attr_reader :outdoor_map
attr_reader :announce_location
attr_reader :can_bicycle
attr_reader :always_bicycle
attr_reader :teleport_destination
attr_reader :weather
attr_reader :town_map_position
attr_reader :dive_map_id
attr_reader :dark_map
attr_reader :safari_map
attr_reader :snap_edges
attr_reader :random_dungeon
attr_reader :battle_background
attr_reader :wild_battle_BGM
attr_reader :trainer_battle_BGM
attr_reader :wild_victory_ME
attr_reader :trainer_victory_ME
attr_reader :wild_capture_ME
attr_reader :town_map_size
attr_reader :battle_environment
DATA = {}
DATA_FILENAME = "map_metadata.dat"
SCHEMA = {
"Outdoor" => [1, "b"],
"ShowArea" => [2, "b"],
"Bicycle" => [3, "b"],
"BicycleAlways" => [4, "b"],
"HealingSpot" => [5, "vuu"],
"Weather" => [6, "eu", :Weather],
"MapPosition" => [7, "uuu"],
"DiveMap" => [8, "v"],
"DarkMap" => [9, "b"],
"SafariMap" => [10, "b"],
"SnapEdges" => [11, "b"],
"Dungeon" => [12, "b"],
"BattleBack" => [13, "s"],
"WildBattleBGM" => [14, "s"],
"TrainerBattleBGM" => [15, "s"],
"WildVictoryME" => [16, "s"],
"TrainerVictoryME" => [17, "s"],
"WildCaptureME" => [18, "s"],
"MapSize" => [19, "us"],
"Environment" => [20, "e", :Environment]
}
extend ClassMethodsIDNumbers
include InstanceMethods
def self.editor_properties
return [
["Outdoor", BooleanProperty, _INTL("If true, this map is an outdoor map and will be tinted according to time of day.")],
["ShowArea", BooleanProperty, _INTL("If true, the game will display the map's name upon entry.")],
["Bicycle", BooleanProperty, _INTL("If true, the bicycle can be used on this map.")],
["BicycleAlways", BooleanProperty, _INTL("If true, the bicycle will be mounted automatically on this map and cannot be dismounted.")],
["HealingSpot", MapCoordsProperty, _INTL("Map ID of this Pokémon Center's town, and X and Y coordinates of its entrance within that town.")],
["Weather", WeatherEffectProperty, _INTL("Weather conditions in effect for this map.")],
["MapPosition", RegionMapCoordsProperty, _INTL("Identifies the point on the regional map for this map.")],
["DiveMap", MapProperty, _INTL("Specifies the underwater layer of this map. Use only if this map has deep water.")],
["DarkMap", BooleanProperty, _INTL("If true, this map is dark and a circle of light appears around the player. Flash can be used to expand the circle.")],
["SafariMap", BooleanProperty, _INTL("If true, this map is part of the Safari Zone (both indoor and outdoor). Not to be used in the reception desk.")],
["SnapEdges", BooleanProperty, _INTL("If true, when the player goes near this map's edge, the game doesn't center the player as usual.")],
["Dungeon", BooleanProperty, _INTL("If true, this map has a randomly generated layout. See the wiki for more information.")],
["BattleBack", StringProperty, _INTL("PNG files named 'XXX_bg', 'XXX_base0', 'XXX_base1', 'XXX_message' in Battlebacks folder, where XXX is this property's value.")],
["WildBattleBGM", BGMProperty, _INTL("Default BGM for wild Pokémon battles on this map.")],
["TrainerBattleBGM", BGMProperty, _INTL("Default BGM for trainer battles on this map.")],
["WildVictoryME", MEProperty, _INTL("Default ME played after winning a wild Pokémon battle on this map.")],
["TrainerVictoryME", MEProperty, _INTL("Default ME played after winning a Trainer battle on this map.")],
["WildCaptureME", MEProperty, _INTL("Default ME played after catching a wild Pokémon on this map.")],
["MapSize", MapSizeProperty, _INTL("The width of the map in Town Map squares, and a string indicating which squares are part of this map.")],
["Environment", GameDataProperty.new(:Environment), _INTL("The default battle environment for battles on this map.")]
]
end
def initialize(hash)
@id = hash[:id]
@outdoor_map = hash[:outdoor_map]
@announce_location = hash[:announce_location]
@can_bicycle = hash[:can_bicycle]
@always_bicycle = hash[:always_bicycle]
@teleport_destination = hash[:teleport_destination]
@weather = hash[:weather]
@town_map_position = hash[:town_map_position]
@dive_map_id = hash[:dive_map_id]
@dark_map = hash[:dark_map]
@safari_map = hash[:safari_map]
@snap_edges = hash[:snap_edges]
@random_dungeon = hash[:random_dungeon]
@battle_background = hash[:battle_background]
@wild_battle_BGM = hash[:wild_battle_BGM]
@trainer_battle_BGM = hash[:trainer_battle_BGM]
@wild_victory_ME = hash[:wild_victory_ME]
@trainer_victory_ME = hash[:trainer_victory_ME]
@wild_capture_ME = hash[:wild_capture_ME]
@town_map_size = hash[:town_map_size]
@battle_environment = hash[:battle_environment]
end
def property_from_string(str)
case str
when "Outdoor" then return @outdoor_map
when "ShowArea" then return @announce_location
when "Bicycle" then return @can_bicycle
when "BicycleAlways" then return @always_bicycle
when "HealingSpot" then return @teleport_destination
when "Weather" then return @weather
when "MapPosition" then return @town_map_position
when "DiveMap" then return @dive_map_id
when "DarkMap" then return @dark_map
when "SafariMap" then return @safari_map
when "SnapEdges" then return @snap_edges
when "Dungeon" then return @random_dungeon
when "BattleBack" then return @battle_background
when "WildBattleBGM" then return @wild_battle_BGM
when "TrainerBattleBGM" then return @trainer_battle_BGM
when "WildVictoryME" then return @wild_victory_ME
when "TrainerVictoryME" then return @trainer_victory_ME
when "WildCaptureME" then return @wild_capture_ME
when "MapSize" then return @town_map_size
when "Environment" then return @battle_environment
end
return nil
end
end
end