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

Merge branch 'dev' into ai

Browse Source
This commit is contained in:
Maruno17
2023-02-10 21:20:28 +00:00
parent 01e98c8f97 becce85550
commit 7e4ef4247b
33 changed files with 341 additions and 1055 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Data/Scripts/001_Technical/003_Intl_Messages.rb
View File

@@ -702,6 +702,7 @@ module MessageTypes
STORAGE_CREATOR_NAME = 27 STORAGE_CREATOR_NAME = 27
ITEM_PORTION_NAMES = 28 ITEM_PORTION_NAMES = 28
ITEM_PORTION_NAME_PLURALS = 29 ITEM_PORTION_NAME_PLURALS = 29
POKEMON_NICKNAMES = 30
@@messages = Translation.new @@messages = Translation.new
def self.load_default_messages def self.load_default_messages

6
Data/Scripts/002_Save data/004_Game_SaveValues.rb
View File

@@ -3,7 +3,7 @@
SaveData.register(:player) do SaveData.register(:player) do
ensure_class :Player ensure_class :Player
save_value { $player } save_value { $player }
load_value { |value| $player = $Trainer = value } load_value { |value| $player = value }
new_game_value { Player.new("Unnamed", GameData::TrainerType.keys.first) } new_game_value { Player.new("Unnamed", GameData::TrainerType.keys.first) }
from_old_format { |old_format| old_format[0] } from_old_format { |old_format| old_format[0] }
end end
@@ -69,7 +69,7 @@ end
SaveData.register(:map_factory) do SaveData.register(:map_factory) do
ensure_class :PokemonMapFactory ensure_class :PokemonMapFactory
save_value { $map_factory } save_value { $map_factory }
load_value { |value| $map_factory = $MapFactory = value } load_value { |value| $map_factory = value }
from_old_format { |old_format| old_format[9] } from_old_format { |old_format| old_format[9] }
end end
@@ -100,7 +100,7 @@ end
SaveData.register(:bag) do SaveData.register(:bag) do
ensure_class :PokemonBag ensure_class :PokemonBag
save_value { $bag } save_value { $bag }
load_value { |value| $bag = $PokemonBag = value } load_value { |value| $bag = value }
new_game_value { PokemonBag.new } new_game_value { PokemonBag.new }
from_old_format { |old_format| old_format[13] } from_old_format { |old_format| old_format[13] }
end end

3
Data/Scripts/002_Save data/005_Game_SaveConversions.rb
View File

@@ -147,7 +147,8 @@ SaveData.register_conversion(:v20_refactor_follower_data) do
display_title "Updating follower data format" display_title "Updating follower data format"
to_value :global_metadata do |global| to_value :global_metadata do |global|
# NOTE: dependentEvents is still defined in class PokemonGlobalMetadata just # NOTE: dependentEvents is still defined in class PokemonGlobalMetadata just
# for the sake of this conversion. It will be removed in future. # for the sake of this conversion. It is deprecated and will be
# removed in v22.
if global.dependentEvents && global.dependentEvents.length > 0 if global.dependentEvents && global.dependentEvents.length > 0
global.followers = [] global.followers = []
global.dependentEvents.each do |follower| global.dependentEvents.each do |follower|

41
Data/Scripts/004_Game classes/012_Game_FollowerFactory.rb
View File

@@ -49,7 +49,7 @@ end
# Permanently stores data of follower events (i.e. in save files). # Permanently stores data of follower events (i.e. in save files).
#=============================================================================== #===============================================================================
class PokemonGlobalMetadata class PokemonGlobalMetadata
attr_accessor :dependentEvents # Deprecated attr_accessor :dependentEvents # Deprecated - to be removed in v22
attr_writer :followers attr_writer :followers
def followers def followers
@@ -387,42 +387,3 @@ module Followers
$game_temp.followers.put_followers_on_player $game_temp.followers.put_followers_on_player
end end
end end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This method is slated to be removed in v21.
def pbAddDependency2(event_id, name, common_event_id)
Deprecation.warn_method("pbAddDependency2", "v21", "Followers.add(event_id, name, common_event_id)")
Followers.add(event_id, name, common_event_id)
end
# @deprecated This method is slated to be removed in v21.
def pbAddDependency(event)
Deprecation.warn_method("pbAddDependency", "v21", "Followers.add_event(event)")
Followers.add_event(event)
end
# @deprecated This method is slated to be removed in v21.
def pbRemoveDependency2(name)
Deprecation.warn_method("pbRemoveDependency2", "v21", "Followers.remove(name)")
Followers.remove(name)
end
# @deprecated This method is slated to be removed in v21.
def pbRemoveDependency(event)
Deprecation.warn_method("pbRemoveDependency", "v21", "Followers.remove_event(event)")
Followers.remove_event(event)
end
# @deprecated This method is slated to be removed in v21.
def pbRemoveDependencies
Deprecation.warn_method("pbRemoveDependencies", "v21", "Followers.clear")
Followers.clear
end
# @deprecated This method is slated to be removed in v21.
def pbGetDependency(name)
Deprecation.warn_method("pbGetDependency", "v21", "Followers.get(name)")
Followers.get(name)
end

7
Data/Scripts/010_Data/001_GameData.rb
View File

@@ -256,7 +256,12 @@ module GameData
ret = [] ret = []
self.constants.each do |c| self.constants.each do |c|
next if !self.const_get(c).is_a?(Class) next if !self.const_get(c).is_a?(Class)
ret.push(self.const_get(c)::DATA_FILENAME) if self.const_get(c).const_defined?(:DATA_FILENAME) next if !self.const_get(c).const_defined?(:DATA_FILENAME)
if self.const_get(c).const_defined?(:OPTIONAL) && self.const_get(c)::OPTIONAL
ret.push([self.const_get(c)::DATA_FILENAME, false])
else
ret.push([self.const_get(c)::DATA_FILENAME, true])
end
end end
return ret return ret
end end

454
Data/Scripts/010_Data/002_PBS data/005_Move.rb
View File

@@ -4,8 +4,7 @@ module GameData
attr_reader :real_name attr_reader :real_name
attr_reader :type attr_reader :type
attr_reader :category attr_reader :category
# TODO: Rename base_damage to power everywhere. attr_reader :power
attr_reader :base_damage
attr_reader :accuracy attr_reader :accuracy
attr_reader :total_pp attr_reader :total_pp
attr_reader :target attr_reader :target
@@ -25,7 +24,7 @@ module GameData
"Name" => [:real_name, "s"], "Name" => [:real_name, "s"],
"Type" => [:type, "e", :Type], "Type" => [:type, "e", :Type],
"Category" => [:category, "e", ["Physical", "Special", "Status"]], "Category" => [:category, "e", ["Physical", "Special", "Status"]],
"Power" => [:base_damage, "u"], "Power" => [:power, "u"],
"Accuracy" => [:accuracy, "u"], "Accuracy" => [:accuracy, "u"],
"TotalPP" => [:total_pp, "u"], "TotalPP" => [:total_pp, "u"],
"Target" => [:target, "e", :Target], "Target" => [:target, "e", :Target],
@@ -40,12 +39,11 @@ module GameData
include InstanceMethods include InstanceMethods
def initialize(hash) def initialize(hash)
convert_move_data(hash)
@id = hash[:id] @id = hash[:id]
@real_name = hash[:real_name] || "Unnamed" @real_name = hash[:real_name] || "Unnamed"
@type = hash[:type] || :NONE @type = hash[:type] || :NONE
@category = hash[:category] || 2 @category = hash[:category] || 2
@base_damage = hash[:base_damage] || 0 @power = hash[:power] || 0
@accuracy = hash[:accuracy] || 100 @accuracy = hash[:accuracy] || 100
@total_pp = hash[:total_pp] || 5 @total_pp = hash[:total_pp] || 5
@target = hash[:target] || :None @target = hash[:target] || :None
@@ -58,6 +56,12 @@ module GameData
@pbs_file_suffix = hash[:pbs_file_suffix] || "" @pbs_file_suffix = hash[:pbs_file_suffix] || ""
end end
# @deprecated This method is slated to be removed in v22.
def base_damage
Deprecation.warn_method("base_damage", "v22", "power")
return @power
end
# @return [String] the translated name of this move # @return [String] the translated name of this move
def name def name
return pbGetMessageFromHash(MessageTypes::MOVE_NAMES, @real_name) return pbGetMessageFromHash(MessageTypes::MOVE_NAMES, @real_name)
@@ -73,13 +77,13 @@ module GameData
end end
def physical? def physical?
return false if @base_damage == 0 return false if @power == 0
return @category == 0 if Settings::MOVE_CATEGORY_PER_MOVE return @category == 0 if Settings::MOVE_CATEGORY_PER_MOVE
return GameData::Type.get(@type).physical? return GameData::Type.get(@type).physical?
end end
def special? def special?
return false if @base_damage == 0 return false if @power == 0
return @category == 1 if Settings::MOVE_CATEGORY_PER_MOVE return @category == 1 if Settings::MOVE_CATEGORY_PER_MOVE
return GameData::Type.get(@type).special? return GameData::Type.get(@type).special?
end end
@@ -360,7 +364,7 @@ module GameData
return 10 if pkmn.item.is_berry? return 10 if pkmn.item.is_berry?
return 80 if pkmn.item.is_mega_stone? return 80 if pkmn.item.is_mega_stone?
if pkmn.item.is_TR? if pkmn.item.is_TR?
ret = GameData::Move.get(pkmn.item.move).base_damage ret = GameData::Move.get(pkmn.item.move).power
ret = 10 if ret < 10 ret = 10 if ret < 10
return ret return ret
end end
@@ -388,444 +392,12 @@ module GameData
return dmgs[ppLeft] return dmgs[ppLeft]
end end
=end =end
return @base_damage return @power
end end
def display_category(pkmn, move = nil); return @category; end def display_category(pkmn, move = nil); return @category; end
def display_accuracy(pkmn, move = nil); return @accuracy; end def display_accuracy(pkmn, move = nil); return @accuracy; end
def convert_move_data(data)
new_code = data[:function_code]
case data[:function_code]
when "000" then new_code = "None"
when "001" then new_code = "DoesNothingUnusableInGravity"
when "002" then new_code = "Struggle"
when "003"
if data[:id] == :RELICSONG
new_code = "SleepTargetChangeUserMeloettaForm"
elsif data[:id] == :DARKVOID && Settings::MECHANICS_GENERATION >= 7
new_code = "SleepTargetIfUserDarkrai"
else
new_code = "SleepTarget"
end
when "004" then new_code = "SleepTargetNextTurn"
when "005" then new_code = "PoisonTarget"
when "006" then new_code = "BadPoisonTarget"
when "007"
if data[:id] == :THUNDERWAVE
new_code = "ParalyzeTargetIfNotTypeImmune"
else
new_code = "ParalyzeTarget"
end
when "008" then new_code = "ParalyzeTargetAlwaysHitsInRainHitsTargetInSky"
when "009" then new_code = "ParalyzeFlinchTarget"
when "00A" then new_code = "BurnTarget"
when "00B" then new_code = "BurnFlinchTarget"
when "00C" then new_code = "FreezeTarget"
when "00D" then new_code = "FreezeTargetAlwaysHitsInHail"
when "00E" then new_code = "FreezeFlinchTarget"
when "00F", "010" then new_code = "FlinchTarget"
when "011" then new_code = "FlinchTargetFailsIfUserNotAsleep"
when "012" then new_code = "FlinchTargetFailsIfNotUserFirstTurn"
when "013", "014" then new_code = "ConfuseTarget"
when "015" then new_code = "ConfuseTargetAlwaysHitsInRainHitsTargetInSky"
when "016" then new_code = "AttractTarget"
when "017" then new_code = "ParalyzeBurnOrFreezeTarget"
when "018" then new_code = "CureUserBurnPoisonParalysis"
when "019" then new_code = "CureUserPartyStatus"
when "01A" then new_code = "StartUserSideImmunityToInflictedStatus"
when "01B" then new_code = "GiveUserStatusToTarget"
when "01C" then new_code = "RaiseUserAttack1"
when "01D" then new_code = "RaiseUserDefense1"
when "01E" then new_code = "RaiseUserDefense1CurlUpUser"
when "01F" then new_code = "RaiseUserSpeed1"
when "020" then new_code = "RaiseUserSpAtk1"
when "021" then new_code = "RaiseUserSpDef1PowerUpElectricMove"
when "022" then new_code = "RaiseUserEvasion1"
when "023" then new_code = "RaiseUserCriticalHitRate2"
when "024" then new_code = "RaiseUserAtkDef1"
when "025" then new_code = "RaiseUserAtkDefAcc1"
when "026" then new_code = "RaiseUserAtkSpd1"
when "027" then new_code = "RaiseUserAtkSpAtk1"
when "028" then new_code = "RaiseUserAtkSpAtk1Or2InSun"
when "029" then new_code = "RaiseUserAtkAcc1"
when "02A" then new_code = "RaiseUserDefSpDef1"
when "02B" then new_code = "RaiseUserSpAtkSpDefSpd1"
when "02C" then new_code = "RaiseUserSpAtkSpDef1"
when "02D" then new_code = "RaiseUserMainStats1"
when "02E" then new_code = "RaiseUserAttack2"
when "02F" then new_code = "RaiseUserDefense2"
when "030" then new_code = "RaiseUserSpeed2"
when "031" then new_code = "RaiseUserSpeed2LowerUserWeight"
when "032" then new_code = "RaiseUserSpAtk2"
when "033" then new_code = "RaiseUserSpDef2"
when "034" then new_code = "RaiseUserEvasion2MinimizeUser"
when "035" then new_code = "LowerUserDefSpDef1RaiseUserAtkSpAtkSpd2"
when "036" then new_code = "RaiseUserAtk1Spd2"
when "037" then new_code = "RaiseTargetRandomStat2"
when "038" then new_code = "RaiseUserDefense3"
when "039" then new_code = "RaiseUserSpAtk3"
when "03A" then new_code = "MaxUserAttackLoseHalfOfTotalHP"
when "03B" then new_code = "LowerUserAtkDef1"
when "03C" then new_code = "LowerUserDefSpDef1"
when "03D" then new_code = "LowerUserDefSpDefSpd1"
when "03E" then new_code = "LowerUserSpeed1"
when "03F" then new_code = "LowerUserSpAtk2"
when "040" then new_code = "RaiseTargetSpAtk1ConfuseTarget"
when "041" then new_code = "RaiseTargetAttack2ConfuseTarget"
when "042" then new_code = "LowerTargetAttack1"
when "043" then new_code = "LowerTargetDefense1"
when "044"
if data[:id] == :BULLDOZE
new_code = "LowerTargetSpeed1WeakerInGrassyTerrain"
else
new_code = "LowerTargetSpeed1"
end
when "045" then new_code = "LowerTargetSpAtk1"
when "046" then new_code = "LowerTargetSpDef1"
when "047" then new_code = "LowerTargetAccuracy1"
when "048"
if data[:id] == :SWEETSCENT && Settings::MECHANICS_GENERATION >= 6
new_code = "LowerTargetEvasion2"
else
new_code = "LowerTargetEvasion1"
end
when "049" then new_code = "LowerTargetEvasion1RemoveSideEffects"
when "04A" then new_code = "LowerTargetAtkDef1"
when "04B" then new_code = "LowerTargetAttack2"
when "04C" then new_code = "LowerTargetDefense2"
when "04D" then new_code = "LowerTargetSpeed2"
when "04E" then new_code = "LowerTargetSpAtk2IfCanAttract"
when "04F" then new_code = "LowerTargetSpDef2"
when "050" then new_code = "ResetTargetStatStages"
when "051" then new_code = "ResetAllBattlersStatStages"
when "052" then new_code = "UserTargetSwapAtkSpAtkStages"
when "053" then new_code = "UserTargetSwapDefSpDefStages"
when "054" then new_code = "UserTargetSwapStatStages"
when "055" then new_code = "UserCopyTargetStatStages"
when "056" then new_code = "StartUserSideImmunityToStatStageLowering"
when "057" then new_code = "UserSwapBaseAtkDef"
when "058" then new_code = "UserTargetAverageBaseAtkSpAtk"
when "059" then new_code = "UserTargetAverageBaseDefSpDef"
when "05A" then new_code = "UserTargetAverageHP"
when "05B" then new_code = "StartUserSideDoubleSpeed"
when "05C" then new_code = "ReplaceMoveThisBattleWithTargetLastMoveUsed"
when "05D" then new_code = "ReplaceMoveWithTargetLastMoveUsed"
when "05E" then new_code = "SetUserTypesToUserMoveType"
when "05F" then new_code = "SetUserTypesToResistLastAttack"
when "060" then new_code = "SetUserTypesBasedOnEnvironment"
when "061" then new_code = "SetTargetTypesToWater"
when "062" then new_code = "SetUserTypesToTargetTypes"
when "063" then new_code = "SetTargetAbilityToSimple"
when "064" then new_code = "SetTargetAbilityToInsomnia"
when "065" then new_code = "SetUserAbilityToTargetAbility"
when "066" then new_code = "SetTargetAbilityToUserAbility"
when "067" then new_code = "UserTargetSwapAbilities"
when "068" then new_code = "NegateTargetAbility"
when "069" then new_code = "TransformUserIntoTarget"
when "06A" then new_code = "FixedDamage20"
when "06B" then new_code = "FixedDamage40"
when "06C" then new_code = "FixedDamageHalfTargetHP"
when "06D" then new_code = "FixedDamageUserLevel"
when "06E" then new_code = "LowerTargetHPToUserHP"
when "06F" then new_code = "FixedDamageUserLevelRandom"
when "070"
if data[:id] == :FISSURE
new_code = "OHKOHitsUndergroundTarget"
elsif data[:id] == :SHEERCOLD && Settings::MECHANICS_GENERATION >= 7
new_code = "OHKOIce"
else
new_code = "OHKO"
end
when "071" then new_code = "CounterPhysicalDamage"
when "072" then new_code = "CounterSpecialDamage"
when "073" then new_code = "CounterDamagePlusHalf"
when "074" then new_code = "DamageTargetAlly"
when "075" then new_code = "DoublePowerIfTargetUnderwater"
when "076" then new_code = "DoublePowerIfTargetUnderground"
when "077" then new_code = "DoublePowerIfTargetInSky"
when "078" then new_code = "FlinchTargetDoublePowerIfTargetInSky"
when "079" then new_code = "DoublePowerAfterFusionFlare"
when "07A" then new_code = "DoublePowerAfterFusionBolt"
when "07B" then new_code = "DoublePowerIfTargetPoisoned"
when "07C" then new_code = "DoublePowerIfTargetParalyzedCureTarget"
when "07D" then new_code = "DoublePowerIfTargetAsleepCureTarget"
when "07E" then new_code = "DoublePowerIfUserPoisonedBurnedParalyzed"
when "07F" then new_code = "DoublePowerIfTargetStatusProblem"
when "080" then new_code = "DoublePowerIfTargetHPLessThanHalf"
when "081" then new_code = "DoublePowerIfUserLostHPThisTurn"
when "082" then new_code = "DoublePowerIfTargetLostHPThisTurn"
when "083" then new_code = "UsedAfterAllyRoundWithDoublePower"
when "084" then new_code = "DoublePowerIfTargetActed"
when "085" then new_code = "DoublePowerIfAllyFaintedLastTurn"
when "086" then new_code = "DoublePowerIfUserHasNoItem"
when "087" then new_code = "TypeAndPowerDependOnWeather"
when "088" then new_code = "PursueSwitchingFoe"
when "089" then new_code = "PowerHigherWithUserHappiness"
when "08A" then new_code = "PowerLowerWithUserHappiness"
when "08B" then new_code = "PowerHigherWithUserHP"
when "08C" then new_code = "PowerHigherWithTargetHP"
when "08D" then new_code = "PowerHigherWithTargetFasterThanUser"
when "08E" then new_code = "PowerHigherWithUserPositiveStatStages"
when "08F" then new_code = "PowerHigherWithTargetPositiveStatStages"
when "090" then new_code = "TypeDependsOnUserIVs"
when "091" then new_code = "PowerHigherWithConsecutiveUse"
when "092" then new_code = "PowerHigherWithConsecutiveUseOnUserSide"
when "093" then new_code = "StartRaiseUserAtk1WhenDamaged"
when "094" then new_code = "RandomlyDamageOrHealTarget"
when "095" then new_code = "RandomPowerDoublePowerIfTargetUnderground"
when "096" then new_code = "TypeAndPowerDependOnUserBerry"
when "097" then new_code = "PowerHigherWithLessPP"
when "098" then new_code = "PowerLowerWithUserHP"
when "099" then new_code = "PowerHigherWithUserFasterThanTarget"
when "09A" then new_code = "PowerHigherWithTargetWeight"
when "09B" then new_code = "PowerHigherWithUserHeavierThanTarget"
when "09C" then new_code = "PowerUpAllyMove"
when "09D" then new_code = "StartWeakenElectricMoves"
when "09E" then new_code = "StartWeakenFireMoves"
when "09F"
case data[:id]
when :MULTIATTACK
new_code = "TypeDependsOnUserMemory"
when :TECHNOBLAST
new_code = "TypeDependsOnUserDrive"
else
new_code = "TypeDependsOnUserPlate"
end
when "0A0" then new_code = "AlwaysCriticalHit"
when "0A1" then new_code = "StartPreventCriticalHitsAgainstUserSide"
when "0A2" then new_code = "StartWeakenPhysicalDamageAgainstUserSide"
when "0A3" then new_code = "StartWeakenSpecialDamageAgainstUserSide"
when "0A4" then new_code = "EffectDependsOnEnvironment"
when "0A5"
new_code = "None"
data[:accuracy] = 0
when "0A6" then new_code = "EnsureNextMoveAlwaysHits"
when "0A7" then new_code = "StartNegateTargetEvasionStatStageAndGhostImmunity"
when "0A8" then new_code = "StartNegateTargetEvasionStatStageAndDarkImmunity"
when "0A9" then new_code = "IgnoreTargetDefSpDefEvaStatStages"
when "0AA" then new_code = "ProtectUser"
when "0AB" then new_code = "ProtectUserSideFromPriorityMoves"
when "0AC" then new_code = "ProtectUserSideFromMultiTargetDamagingMoves"
when "0AD" then new_code = "RemoveProtections"
when "0AE" then new_code = "UseLastMoveUsedByTarget"
when "0AF" then new_code = "UseLastMoveUsed"
when "0B0" then new_code = "UseMoveTargetIsAboutToUse"
when "0B1" then new_code = "BounceBackProblemCausingStatusMoves"
when "0B2" then new_code = "StealAndUseBeneficialStatusMove"
when "0B3" then new_code = "UseMoveDependingOnEnvironment"
when "0B4" then new_code = "UseRandomUserMoveIfAsleep"
when "0B5" then new_code = "UseRandomMoveFromUserParty"
when "0B6" then new_code = "UseRandomMove"
when "0B7" then new_code = "DisableTargetUsingSameMoveConsecutively"
when "0B8" then new_code = "DisableTargetMovesKnownByUser"
when "0B9" then new_code = "DisableTargetLastMoveUsed"
when "0BA" then new_code = "DisableTargetStatusMoves"
when "0BB" then new_code = "DisableTargetHealingMoves"
when "0BC" then new_code = "DisableTargetUsingDifferentMove"
when "0BD" then new_code = "HitTwoTimes"
when "0BE" then new_code = "HitTwoTimesPoisonTarget"
when "0BF" then new_code = "HitThreeTimesPowersUpWithEachHit"
when "0C0"
if data[:id] == :WATERSHURIKEN
new_code = "HitTwoToFiveTimesOrThreeForAshGreninja"
else
new_code = "HitTwoToFiveTimes"
end
when "0C1" then new_code = "HitOncePerUserTeamMember"
when "0C2" then new_code = "AttackAndSkipNextTurn"
when "0C3" then new_code = "TwoTurnAttack"
when "0C4" then new_code = "TwoTurnAttackOneTurnInSun"
when "0C5" then new_code = "TwoTurnAttackParalyzeTarget"
when "0C6" then new_code = "TwoTurnAttackBurnTarget"
when "0C7" then new_code = "TwoTurnAttackFlinchTarget"
when "0C8" then new_code = "TwoTurnAttackChargeRaiseUserDefense1"
when "0C9" then new_code = "TwoTurnAttackInvulnerableInSky"
when "0CA" then new_code = "TwoTurnAttackInvulnerableUnderground"
when "0CB" then new_code = "TwoTurnAttackInvulnerableUnderwater"
when "0CC" then new_code = "TwoTurnAttackInvulnerableInSkyParalyzeTarget"
when "0CD" then new_code = "TwoTurnAttackInvulnerableRemoveProtections"
when "0CE" then new_code = "TwoTurnAttackInvulnerableInSkyTargetCannotAct"
when "0CF" then new_code = "BindTarget"
when "0D0" then new_code = "BindTargetDoublePowerIfTargetUnderwater"
when "0D1" then new_code = "MultiTurnAttackPreventSleeping"
when "0D2" then new_code = "MultiTurnAttackConfuseUserAtEnd"
when "0D3" then new_code = "MultiTurnAttackPowersUpEachTurn"
when "0D4" then new_code = "MultiTurnAttackBideThenReturnDoubleDamage"
when "0D5" then new_code = "HealUserHalfOfTotalHP"
when "0D6" then new_code = "HealUserHalfOfTotalHPLoseFlyingTypeThisTurn"
when "0D7" then new_code = "HealUserPositionNextTurn"
when "0D8" then new_code = "HealUserDependingOnWeather"
when "0D9" then new_code = "HealUserFullyAndFallAsleep"
when "0DA" then new_code = "StartHealUserEachTurn"
when "0DB" then new_code = "StartHealUserEachTurnTrapUserInBattle"
when "0DC" then new_code = "StartLeechSeedTarget"
when "0DD" then new_code = "HealUserByHalfOfDamageDone"
when "0DE" then new_code = "HealUserByHalfOfDamageDoneIfTargetAsleep"
when "0DF" then new_code = "HealTargetHalfOfTotalHP"
when "0E0" then new_code = "UserFaintsExplosive"
when "0E1" then new_code = "UserFaintsFixedDamageUserHP"
when "0E2" then new_code = "UserFaintsLowerTargetAtkSpAtk2"
when "0E3" then new_code = "UserFaintsHealAndCureReplacement"
when "0E4" then new_code = "UserFaintsHealAndCureReplacementRestorePP"
when "0E5" then new_code = "StartPerishCountsForAllBattlers"
when "0E6" then new_code = "SetAttackerMovePPTo0IfUserFaints"
when "0E7" then new_code = "AttackerFaintsIfUserFaints"
when "0E8" then new_code = "UserEnduresFaintingThisTurn"
when "0E9" then new_code = "CannotMakeTargetFaint"
when "0EA"
if Settings::MECHANICS_GENERATION >= 8
new_code = "SwitchOutUserStatusMove"
else
new_code = "FleeFromBattle"
end
when "0EB" then new_code = "SwitchOutTargetStatusMove"
when "0EC" then new_code = "SwitchOutTargetDamagingMove"
when "0ED" then new_code = "SwitchOutUserPassOnEffects"
when "0EE" then new_code = "SwitchOutUserDamagingMove"
when "0EF" then new_code = "TrapTargetInBattle"
when "0F0" then new_code = "RemoveTargetItem"
when "0F1" then new_code = "UserTakesTargetItem"
when "0F2" then new_code = "UserTargetSwapItems"
when "0F3" then new_code = "TargetTakesUserItem"
when "0F4" then new_code = "UserConsumeTargetBerry"
when "0F5" then new_code = "DestroyTargetBerryOrGem"
when "0F6" then new_code = "RestoreUserConsumedItem"
when "0F7" then new_code = "ThrowUserItemAtTarget"
when "0F8" then new_code = "StartTargetCannotUseItem"
when "0F9" then new_code = "StartNegateHeldItems"
when "0FA" then new_code = "RecoilQuarterOfDamageDealt"
when "0FB" then new_code = "RecoilThirdOfDamageDealt"
when "0FC" then new_code = "RecoilHalfOfDamageDealt"
when "0FD" then new_code = "RecoilThirdOfDamageDealtParalyzeTarget"
when "0FE" then new_code = "RecoilThirdOfDamageDealtBurnTarget"
when "0FF" then new_code = "StartSunWeather"
when "100" then new_code = "StartRainWeather"
when "101" then new_code = "StartSandstormWeather"
when "102" then new_code = "StartHailWeather"
when "103" then new_code = "AddSpikesToFoeSide"
when "104" then new_code = "AddToxicSpikesToFoeSide"
when "105" then new_code = "AddStealthRocksToFoeSide"
when "106" then new_code = "GrassPledge"
when "107" then new_code = "FirePledge"
when "108" then new_code = "WaterPledge"
when "109" then new_code = "AddMoneyGainedFromBattle"
when "10A" then new_code = "RemoveScreens"
when "10B" then new_code = "CrashDamageIfFailsUnusableInGravity"
when "10C" then new_code = "UserMakeSubstitute"
when "10D" then new_code = "CurseTargetOrLowerUserSpd1RaiseUserAtkDef1"
when "10E" then new_code = "LowerPPOfTargetLastMoveBy4"
when "10F" then new_code = "StartDamageTargetEachTurnIfTargetAsleep"
when "110" then new_code = "RemoveUserBindingAndEntryHazards"
when "111" then new_code = "AttackTwoTurnsLater"
when "112" then new_code = "UserAddStockpileRaiseDefSpDef1"
when "113" then new_code = "PowerDependsOnUserStockpile"
when "114" then new_code = "HealUserDependingOnUserStockpile"
when "115" then new_code = "FailsIfUserDamagedThisTurn"
when "116" then new_code = "FailsIfTargetActed"
when "117" then new_code = "RedirectAllMovesToUser"
when "118" then new_code = "StartGravity"
when "119" then new_code = "StartUserAirborne"
when "11A" then new_code = "StartTargetAirborneAndAlwaysHitByMoves"
when "11B" then new_code = "HitsTargetInSky"
when "11C" then new_code = "HitsTargetInSkyGroundsTarget"
when "11D" then new_code = "TargetActsNext"
when "11E" then new_code = "TargetActsLast"
when "11F" then new_code = "StartSlowerBattlersActFirst"
when "120" then new_code = "UserSwapsPositionsWithAlly"
when "121" then new_code = "UseTargetAttackInsteadOfUserAttack"
when "122" then new_code = "UseTargetDefenseInsteadOfTargetSpDef"
when "123" then new_code = "FailsUnlessTargetSharesTypeWithUser"
when "124" then new_code = "StartSwapAllBattlersBaseDefensiveStats"
when "125" then new_code = "FailsIfUserHasUnusedMove"
when "126" then new_code = "None"
when "127" then new_code = "ParalyzeTarget"
when "128" then new_code = "BurnTarget"
when "129" then new_code = "FreezeTarget"
when "12A" then new_code = "ConfuseTarget"
when "12B" then new_code = "LowerTargetDefense2"
when "12C" then new_code = "LowerTargetEvasion2"
when "12D" then new_code = "DoublePowerIfTargetUnderwater"
when "12E" then new_code = "AllBattlersLoseHalfHPUserSkipsNextTurn"
when "12F" then new_code = "TrapTargetInBattle"
when "130" then new_code = "UserLosesHalfHP"
when "131" then new_code = "StartShadowSkyWeather"
when "132" then new_code = "RemoveAllScreensAndSafeguard"
when "133" then new_code = "DoesNothingFailsIfNoAlly"
when "134" then new_code = "DoesNothingCongratulations"
when "135" then new_code = "FreezeTargetSuperEffectiveAgainstWater"
when "136" then new_code = "RaiseUserDefense2"
when "137" then new_code = "RaisePlusMinusUserAndAlliesDefSpDef1"
when "138" then new_code = "RaiseTargetSpDef1"
when "139" then new_code = "LowerTargetAttack1BypassSubstitute"
when "13A" then new_code = "LowerTargetAtkSpAtk1"
when "13B" then new_code = "HoopaRemoveProtectionsBypassSubstituteLowerUserDef1"
when "13C" then new_code = "LowerTargetSpAtk1"
when "13D" then new_code = "LowerTargetSpAtk2"
when "13E" then new_code = "RaiseGroundedGrassBattlersAtkSpAtk1"
when "13F" then new_code = "RaiseGrassBattlersDef1"
when "140" then new_code = "LowerPoisonedTargetAtkSpAtkSpd1"
when "141" then new_code = "InvertTargetStatStages"
when "142" then new_code = "AddGhostTypeToTarget"
when "143" then new_code = "AddGrassTypeToTarget"
when "144" then new_code = "EffectivenessIncludesFlyingType"
when "145" then new_code = "TargetMovesBecomeElectric"
when "146" then new_code = "NormalMovesBecomeElectric"
when "147" then new_code = "RemoveProtectionsBypassSubstitute"
when "148" then new_code = "TargetNextFireMoveDamagesTarget"
when "149" then new_code = "ProtectUserSideFromDamagingMovesIfUserFirstTurn"
when "14A" then new_code = "ProtectUserSideFromStatusMoves"
when "14B" then new_code = "ProtectUserFromDamagingMovesKingsShield"
when "14C" then new_code = "ProtectUserFromTargetingMovesSpikyShield"
when "14D" then new_code = "TwoTurnAttackInvulnerableRemoveProtections"
when "14E" then new_code = "TwoTurnAttackRaiseUserSpAtkSpDefSpd2"
when "14F" then new_code = "HealUserByThreeQuartersOfDamageDone"
when "150" then new_code = "RaiseUserAttack3IfTargetFaints"
when "151" then new_code = "LowerTargetAtkSpAtk1SwitchOutUser"
when "152" then new_code = "TrapAllBattlersInBattleForOneTurn"
when "153" then new_code = "AddStickyWebToFoeSide"
when "154" then new_code = "StartElectricTerrain"
when "155" then new_code = "StartGrassyTerrain"
when "156" then new_code = "StartMistyTerrain"
when "157" then new_code = "DoubleMoneyGainedFromBattle"
when "158" then new_code = "FailsIfUserNotConsumedBerry"
when "159" then new_code = "PoisonTargetLowerTargetSpeed1"
when "15A" then new_code = "CureTargetBurn"
when "15B" then new_code = "CureTargetStatusHealUserHalfOfTotalHP"
when "15C" then new_code = "RaisePlusMinusUserAndAlliesAtkSpAtk1"
when "15D" then new_code = "UserStealTargetPositiveStatStages"
when "15E" then new_code = "EnsureNextCriticalHit"
when "15F" then new_code = "LowerUserDefense1"
when "160" then new_code = "HealUserByTargetAttackLowerTargetAttack1"
when "161" then new_code = "UserTargetSwapBaseSpeed"
when "162" then new_code = "UserLosesFireType"
when "163" then new_code = "IgnoreTargetAbility"
when "164" then new_code = "CategoryDependsOnHigherDamageIgnoreTargetAbility"
when "165" then new_code = "NegateTargetAbilityIfTargetActed"
when "166" then new_code = "DoublePowerIfUserLastMoveFailed"
when "167" then new_code = "StartWeakenDamageAgainstUserSideIfHail"
when "168" then new_code = "ProtectUserBanefulBunker"
when "169" then new_code = "TypeIsUserFirstType"
when "16A" then new_code = "RedirectAllMovesToTarget"
when "16B" then new_code = "TargetUsesItsLastUsedMoveAgain"
when "16C" then new_code = "DisableTargetSoundMoves"
when "16D" then new_code = "HealUserDependingOnSandstorm"
when "16E" then new_code = "HealTargetDependingOnGrassyTerrain"
when "16F" then new_code = "HealAllyOrDamageFoe"
when "170" then new_code = "UserLosesHalfOfTotalHPExplosive"
when "171" then new_code = "UsedAfterUserTakesPhysicalDamage"
when "172" then new_code = "BurnAttackerBeforeUserActs"
when "173" then new_code = "StartPsychicTerrain"
when "174" then new_code = "FailsIfNotUserFirstTurn"
when "175" then new_code = "HitTwoTimesFlinchTarget"
#=========================================================================
# NOTE: The below was added in v21.
when "UseUserBaseDefenseInsteadOfUserBaseAttack" then new_code = "UseUserDefenseInsteadOfUserAttack"
end
data[:function_code] = new_code
return data
end
alias __orig__get_property_for_PBS get_property_for_PBS unless method_defined?(:__orig__get_property_for_PBS) alias __orig__get_property_for_PBS get_property_for_PBS unless method_defined?(:__orig__get_property_for_PBS)
def get_property_for_PBS(key) def get_property_for_PBS(key)
ret = __orig__get_property_for_PBS(key) ret = __orig__get_property_for_PBS(key)

28
Data/Scripts/010_Data/002_PBS data/006_Item.rb
View File

@@ -50,19 +50,21 @@ module GameData
battle_use_array = [_INTL("Can't use in battle")] battle_use_array = [_INTL("Can't use in battle")]
self.schema["BattleUse"][2].each { |key, value| battle_use_array[value] = key if !battle_use_array[value] } self.schema["BattleUse"][2].each { |key, value| battle_use_array[value] = key if !battle_use_array[value] }
return [ return [
["ID", ReadOnlyProperty, _INTL("ID of this item (used as a symbol like :XXX).")], ["ID", ReadOnlyProperty, _INTL("ID of this item (used as a symbol like :XXX).")],
["Name", ItemNameProperty, _INTL("Name of this item as displayed by the game.")], ["Name", ItemNameProperty, _INTL("Name of this item as displayed by the game.")],
["NamePlural", ItemNameProperty, _INTL("Plural name of this item as displayed by the game.")], ["NamePlural", ItemNameProperty, _INTL("Plural name of this item as displayed by the game.")],
["Pocket", PocketProperty, _INTL("Pocket in the Bag where this item is stored.")], ["PortionName", ItemNameProperty, _INTL("Name of a portion of this item as displayed by the game.")],
["Price", LimitProperty.new(Settings::MAX_MONEY), _INTL("Purchase price of this item.")], ["PortionNamePlural", ItemNameProperty, _INTL("Name of 2 or more portions of this item as displayed by the game.")],
["SellPrice", LimitProperty2.new(Settings::MAX_MONEY), _INTL("Sell price of this item. If blank, is half the purchase price.")], ["Pocket", PocketProperty, _INTL("Pocket in the Bag where this item is stored.")],
["BPPrice", LimitProperty.new(Settings::MAX_BATTLE_POINTS), _INTL("Purchase price of this item in Battle Points (BP).")], ["Price", LimitProperty.new(Settings::MAX_MONEY), _INTL("Purchase price of this item.")],
["FieldUse", EnumProperty.new(field_use_array), _INTL("How this item can be used outside of battle.")], ["SellPrice", LimitProperty2.new(Settings::MAX_MONEY), _INTL("Sell price of this item. If blank, is half the purchase price.")],
["BattleUse", EnumProperty.new(battle_use_array), _INTL("How this item can be used within a battle.")], ["BPPrice", LimitProperty.new(Settings::MAX_BATTLE_POINTS), _INTL("Purchase price of this item in Battle Points (BP).")],
["Flags", StringListProperty, _INTL("Words/phrases that can be used to group certain kinds of items.")], ["FieldUse", EnumProperty.new(field_use_array), _INTL("How this item can be used outside of battle.")],
["Consumable", BooleanProperty, _INTL("Whether this item is consumed after use.")], ["BattleUse", EnumProperty.new(battle_use_array), _INTL("How this item can be used within a battle.")],
["Move", MoveProperty, _INTL("Move taught by this HM, TM or TR.")], ["Flags", StringListProperty, _INTL("Words/phrases that can be used to group certain kinds of items.")],
["Description", StringProperty, _INTL("Description of this item.")] ["Consumable", BooleanProperty, _INTL("Whether this item is consumed after use.")],
["Move", MoveProperty, _INTL("Move taught by this HM, TM or TR.")],
["Description", StringProperty, _INTL("Description of this item.")]
] ]
end end

3
Data/Scripts/010_Data/002_PBS data/011_ShadowPokemon.rb
View File

@@ -9,6 +9,7 @@ module GameData
DATA = {} DATA = {}
DATA_FILENAME = "shadow_pokemon.dat" DATA_FILENAME = "shadow_pokemon.dat"
PBS_BASE_FILENAME = "shadow_pokemon" PBS_BASE_FILENAME = "shadow_pokemon"
OPTIONAL = true
SCHEMA = { SCHEMA = {
"SectionName" => [:id, "e", :Species], "SectionName" => [:id, "e", :Species],
@@ -21,7 +22,7 @@ module GameData
extend ClassMethodsSymbols extend ClassMethodsSymbols
include InstanceMethods include InstanceMethods
alias __orig__load load unless private_method_defined?(:__orig__load) singleton_class.alias_method(:__orig__load, :load) unless singleton_class.method_defined?(:__orig__load)
def self.load def self.load
__orig__load if safeExists?("Data/#{self::DATA_FILENAME}") __orig__load if safeExists?("Data/#{self::DATA_FILENAME}")
end end

4
Data/Scripts/010_Data/002_PBS data/015_Trainer.rb
View File

@@ -167,7 +167,9 @@ module GameData
end end
end end
pkmn.happiness = pkmn_data[:happiness] if pkmn_data[:happiness] pkmn.happiness = pkmn_data[:happiness] if pkmn_data[:happiness]
pkmn.name = pkmn_data[:real_name] if !nil_or_empty?(pkmn_data[:real_name]) if !nil_or_empty?(pkmn_data[:real_name])
pkmn.name = pbGetMessageFromHash(MessageTypes::POKEMON_NICKNAMES, pkmn_data[:real_name])
end
if pkmn_data[:shadowness] if pkmn_data[:shadowness]
pkmn.makeShadow pkmn.makeShadow
pkmn.shiny = false pkmn.shiny = false

4
Data/Scripts/011_Battle/002_Battler/006_Battler_AbilityAndItem.rb
View File

@@ -461,9 +461,9 @@ class Battle::Battler
return if move_type != gem_type return if move_type != gem_type
@effects[PBEffects::GemConsumed] = @item_id @effects[PBEffects::GemConsumed] = @item_id
if Settings::MECHANICS_GENERATION >= 6 if Settings::MECHANICS_GENERATION >= 6
mults[:base_damage_multiplier] *= 1.3 mults[:power_multiplier] *= 1.3
else else
mults[:base_damage_multiplier] *= 1.5 mults[:power_multiplier] *= 1.5
end end
end end
end end

12
Data/Scripts/011_Battle/003_Move/001_Battle_Move.rb
View File

@@ -4,7 +4,7 @@ class Battle::Move
attr_accessor :id attr_accessor :id
attr_reader :name attr_reader :name
attr_reader :function attr_reader :function
attr_reader :baseDamage attr_reader :power
attr_reader :type attr_reader :type
attr_reader :category attr_reader :category
attr_reader :accuracy attr_reader :accuracy
@@ -22,6 +22,12 @@ class Battle::Move
def to_int; return @id; end def to_int; return @id; end
# @deprecated This method is slated to be removed in v22.
def baseDamage
Deprecation.warn_method("baseDamage", "v22", "power")
return @power
end
#============================================================================= #=============================================================================
# Creating a move # Creating a move
#============================================================================= #=============================================================================
@@ -32,7 +38,7 @@ class Battle::Move
@name = move.name # Get the move's name @name = move.name # Get the move's name
# Get data on the move # Get data on the move
@function = move.function_code @function = move.function_code
@baseDamage = move.base_damage @power = move.power
@type = move.type @type = move.type
@category = move.category @category = move.category
@accuracy = move.accuracy @accuracy = move.accuracy
@@ -173,7 +179,7 @@ class Battle::Move
"PowerHigherWithUserHP", "PowerLowerWithUserHP", "PowerHigherWithUserHP", "PowerLowerWithUserHP",
"PowerHigherWithUserHappiness", "PowerLowerWithUserHappiness", "PowerHigherWithUserHappiness", "PowerLowerWithUserHappiness",
"PowerHigherWithUserPositiveStatStages", "PowerDependsOnUserStockpile" "PowerHigherWithUserPositiveStatStages", "PowerDependsOnUserStockpile"
return pbBaseType(@baseDamage, battler, nil) return pbBaseType(@power, battler, nil)
end end
=end =end
return @realMove.display_damage(battler.pokemon) return @realMove.display_damage(battler.pokemon)

36
Data/Scripts/011_Battle/003_Move/003_Move_UsageCalculations.rb
View File

@@ -248,7 +248,7 @@ class Battle::Move
# Calculate whether this hit deals critical damage # Calculate whether this hit deals critical damage
target.damageState.critical = pbIsCritical?(user, target) target.damageState.critical = pbIsCritical?(user, target)
# Calcuate base power of move # Calcuate base power of move
baseDmg = pbBaseDamage(@baseDamage, user, target) baseDmg = pbBaseDamage(@power, user, target)
# Calculate user's attack stat # Calculate user's attack stat
atk, atkStage = pbGetAttackStats(user, target) atk, atkStage = pbGetAttackStats(user, target)
if !target.hasActiveAbility?(:UNAWARE) || @battle.moldBreaker if !target.hasActiveAbility?(:UNAWARE) || @battle.moldBreaker
@@ -263,14 +263,14 @@ class Battle::Move
end end
# Calculate all multiplier effects # Calculate all multiplier effects
multipliers = { multipliers = {
:base_damage_multiplier => 1.0, :power_multiplier => 1.0,
:attack_multiplier => 1.0, :attack_multiplier => 1.0,
:defense_multiplier => 1.0, :defense_multiplier => 1.0,
:final_damage_multiplier => 1.0 :final_damage_multiplier => 1.0
} }
pbCalcDamageMultipliers(user, target, numTargets, type, baseDmg, multipliers) pbCalcDamageMultipliers(user, target, numTargets, type, baseDmg, multipliers)
# Main damage calculation # Main damage calculation
baseDmg = [(baseDmg * multipliers[:base_damage_multiplier]).round, 1].max baseDmg = [(baseDmg * multipliers[:power_multiplier]).round, 1].max
atk = [(atk * multipliers[:attack_multiplier]).round, 1].max atk = [(atk * multipliers[:attack_multiplier]).round, 1].max
defense = [(defense * multipliers[:defense_multiplier]).round, 1].max defense = [(defense * multipliers[:defense_multiplier]).round, 1].max
damage = ((((2.0 * user.level / 5) + 2).floor * baseDmg * atk / defense).floor / 50).floor + 2 damage = ((((2.0 * user.level / 5) + 2).floor * baseDmg * atk / defense).floor / 50).floor + 2
@@ -283,9 +283,9 @@ class Battle::Move
if (@battle.pbCheckGlobalAbility(:DARKAURA) && type == :DARK) || if (@battle.pbCheckGlobalAbility(:DARKAURA) && type == :DARK) ||
(@battle.pbCheckGlobalAbility(:FAIRYAURA) && type == :FAIRY) (@battle.pbCheckGlobalAbility(:FAIRYAURA) && type == :FAIRY)
if @battle.pbCheckGlobalAbility(:AURABREAK) if @battle.pbCheckGlobalAbility(:AURABREAK)
multipliers[:base_damage_multiplier] *= 2 / 3.0 multipliers[:power_multiplier] *= 2 / 3.0
else else
multipliers[:base_damage_multiplier] *= 4 / 3.0 multipliers[:power_multiplier] *= 4 / 3.0
end end
end end
# Ability effects that alter damage # Ability effects that alter damage
@@ -336,47 +336,47 @@ class Battle::Move
end end
# Parental Bond's second attack # Parental Bond's second attack
if user.effects[PBEffects::ParentalBond] == 1 if user.effects[PBEffects::ParentalBond] == 1
multipliers[:base_damage_multiplier] /= (Settings::MECHANICS_GENERATION >= 7) ? 4 : 2 multipliers[:power_multiplier] /= (Settings::MECHANICS_GENERATION >= 7) ? 4 : 2
end end
# Other # Other
if user.effects[PBEffects::MeFirst] if user.effects[PBEffects::MeFirst]
multipliers[:base_damage_multiplier] *= 1.5 multipliers[:power_multiplier] *= 1.5
end end
if user.effects[PBEffects::HelpingHand] && !self.is_a?(Battle::Move::Confusion) if user.effects[PBEffects::HelpingHand] && !self.is_a?(Battle::Move::Confusion)
multipliers[:base_damage_multiplier] *= 1.5 multipliers[:power_multiplier] *= 1.5
end end
if user.effects[PBEffects::Charge] > 0 && type == :ELECTRIC if user.effects[PBEffects::Charge] > 0 && type == :ELECTRIC
multipliers[:base_damage_multiplier] *= 2 multipliers[:power_multiplier] *= 2
end end
# Mud Sport # Mud Sport
if type == :ELECTRIC if type == :ELECTRIC
if @battle.allBattlers.any? { |b| b.effects[PBEffects::MudSport] } if @battle.allBattlers.any? { |b| b.effects[PBEffects::MudSport] }
multipliers[:base_damage_multiplier] /= 3 multipliers[:power_multiplier] /= 3
end end
if @battle.field.effects[PBEffects::MudSportField] > 0 if @battle.field.effects[PBEffects::MudSportField] > 0
multipliers[:base_damage_multiplier] /= 3 multipliers[:power_multiplier] /= 3
end end
end end
# Water Sport # Water Sport
if type == :FIRE if type == :FIRE
if @battle.allBattlers.any? { |b| b.effects[PBEffects::WaterSport] } if @battle.allBattlers.any? { |b| b.effects[PBEffects::WaterSport] }
multipliers[:base_damage_multiplier] /= 3 multipliers[:power_multiplier] /= 3
end end
if @battle.field.effects[PBEffects::WaterSportField] > 0 if @battle.field.effects[PBEffects::WaterSportField] > 0
multipliers[:base_damage_multiplier] /= 3 multipliers[:power_multiplier] /= 3
end end
end end
# Terrain moves # Terrain moves
terrain_multiplier = (Settings::MECHANICS_GENERATION >= 8) ? 1.3 : 1.5 terrain_multiplier = (Settings::MECHANICS_GENERATION >= 8) ? 1.3 : 1.5
case @battle.field.terrain case @battle.field.terrain
when :Electric when :Electric
multipliers[:base_damage_multiplier] *= terrain_multiplier if type == :ELECTRIC && user.affectedByTerrain? multipliers[:power_multiplier] *= terrain_multiplier if type == :ELECTRIC && user.affectedByTerrain?
when :Grassy when :Grassy
multipliers[:base_damage_multiplier] *= terrain_multiplier if type == :GRASS && user.affectedByTerrain? multipliers[:power_multiplier] *= terrain_multiplier if type == :GRASS && user.affectedByTerrain?
when :Psychic when :Psychic
multipliers[:base_damage_multiplier] *= terrain_multiplier if type == :PSYCHIC && user.affectedByTerrain? multipliers[:power_multiplier] *= terrain_multiplier if type == :PSYCHIC && user.affectedByTerrain?
when :Misty when :Misty
multipliers[:base_damage_multiplier] /= 2 if type == :DRAGON && target.affectedByTerrain? multipliers[:power_multiplier] /= 2 if type == :DRAGON && target.affectedByTerrain?
end end
# Badge multipliers # Badge multipliers
if @battle.internalBattle if @battle.internalBattle
@@ -476,7 +476,7 @@ class Battle::Move
multipliers[:final_damage_multiplier] *= 2 multipliers[:final_damage_multiplier] *= 2
end end
# Move-specific base damage modifiers # Move-specific base damage modifiers
multipliers[:base_damage_multiplier] = pbBaseDamageMultiplier(multipliers[:base_damage_multiplier], user, target) multipliers[:power_multiplier] = pbBaseDamageMultiplier(multipliers[:power_multiplier], user, target)
# Move-specific final damage modifiers # Move-specific final damage modifiers
multipliers[:final_damage_multiplier] = pbModifyDamage(multipliers[:final_damage_multiplier], user, target) multipliers[:final_damage_multiplier] = pbModifyDamage(multipliers[:final_damage_multiplier], user, target)
end end

4
Data/Scripts/011_Battle/003_Move/004_Move_BaseEffects.rb
View File

@@ -27,7 +27,7 @@ class Battle::Move::Confusion < Battle::Move
@id = :CONFUSEDAMAGE @id = :CONFUSEDAMAGE
@name = "" @name = ""
@function = "None" @function = "None"
@baseDamage = 40 @power = 40
@type = nil @type = nil
@category = 0 @category = 0
@accuracy = 100 @accuracy = 100
@@ -56,7 +56,7 @@ class Battle::Move::Struggle < Battle::Move
@id = (move) ? move.id : :STRUGGLE @id = (move) ? move.id : :STRUGGLE
@name = (move) ? move.name : _INTL("Struggle") @name = (move) ? move.name : _INTL("Struggle")
@function = "Struggle" @function = "Struggle"
@baseDamage = 50 @power = 50
@type = nil @type = nil
@category = 0 @category = 0
@accuracy = 0 @accuracy = 0

2
Data/Scripts/011_Battle/003_Move/008_MoveEffects_MoveAttributes.rb
View File

@@ -331,7 +331,7 @@ class Battle::Move::PowerHigherWithConsecutiveUse < Battle::Move
oldVal = user.effects[PBEffects::FuryCutter] oldVal = user.effects[PBEffects::FuryCutter]
super super
maxMult = 1 maxMult = 1
while (@baseDamage << (maxMult - 1)) < 160 while (@power << (maxMult - 1)) < 160
maxMult += 1 # 1-4 for base damage of 20, 1-3 for base damage of 40 maxMult += 1 # 1-4 for base damage of 20, 1-3 for base damage of 40
end end
user.effects[PBEffects::FuryCutter] = (oldVal >= maxMult) ? maxMult : oldVal + 1 user.effects[PBEffects::FuryCutter] = (oldVal >= maxMult) ? maxMult : oldVal + 1

174
Data/Scripts/011_Battle/006_Other battle code/008_Battle_AbilityEffects.rb
View File

@@ -185,24 +185,24 @@ module Battle::AbilityEffects
#============================================================================= #=============================================================================
def self.triggerDamageCalcFromUser(ability, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromUser(ability, user, target, move, mults, power, type)
DamageCalcFromUser.trigger(ability, user, target, move, mults, base_damage, type) DamageCalcFromUser.trigger(ability, user, target, move, mults, power, type)
end end
def self.triggerDamageCalcFromAlly(ability, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromAlly(ability, user, target, move, mults, power, type)
DamageCalcFromAlly.trigger(ability, user, target, move, mults, base_damage, type) DamageCalcFromAlly.trigger(ability, user, target, move, mults, power, type)
end end
def self.triggerDamageCalcFromTarget(ability, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromTarget(ability, user, target, move, mults, power, type)
DamageCalcFromTarget.trigger(ability, user, target, move, mults, base_damage, type) DamageCalcFromTarget.trigger(ability, user, target, move, mults, power, type)
end end
def self.triggerDamageCalcFromTargetNonIgnorable(ability, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromTargetNonIgnorable(ability, user, target, move, mults, power, type)
DamageCalcFromTargetNonIgnorable.trigger(ability, user, target, move, mults, base_damage, type) DamageCalcFromTargetNonIgnorable.trigger(ability, user, target, move, mults, power, type)
end end
def self.triggerDamageCalcFromTargetAlly(ability, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromTargetAlly(ability, user, target, move, mults, power, type)
DamageCalcFromTargetAlly.trigger(ability, user, target, move, mults, base_damage, type) DamageCalcFromTargetAlly.trigger(ability, user, target, move, mults, power, type)
end end
def self.triggerCriticalCalcFromUser(ability, user, target, crit_stage) def self.triggerCriticalCalcFromUser(ability, user, target, crit_stage)
@@ -1195,15 +1195,15 @@ Battle::AbilityEffects::AccuracyCalcFromTarget.add(:WONDERSKIN,
#=============================================================================== #===============================================================================
Battle::AbilityEffects::DamageCalcFromUser.add(:AERILATE, Battle::AbilityEffects::DamageCalcFromUser.add(:AERILATE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if move.powerBoost mults[:power_multiplier] *= 1.2 if move.powerBoost
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.copy(:AERILATE, :PIXILATE, :REFRIGERATE, :GALVANIZE, :NORMALIZE) Battle::AbilityEffects::DamageCalcFromUser.copy(:AERILATE, :PIXILATE, :REFRIGERATE, :GALVANIZE, :NORMALIZE)
Battle::AbilityEffects::DamageCalcFromUser.add(:ANALYTIC, Battle::AbilityEffects::DamageCalcFromUser.add(:ANALYTIC,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
# NOTE: In the official games, if another battler faints earlier in the # NOTE: In the official games, if another battler faints earlier in the
# round but it would have moved after the user, then Analytic does not # round but it would have moved after the user, then Analytic does not
# power up the move. However, this makes the determination so much # power up the move. However, this makes the determination so much
@@ -1213,13 +1213,13 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:ANALYTIC,
# "power up the move if all other battlers on the field right now have # "power up the move if all other battlers on the field right now have
# already moved". # already moved".
if move.pbMoveFailedLastInRound?(user, false) if move.pbMoveFailedLastInRound?(user, false)
mults[:base_damage_multiplier] *= 1.3 mults[:power_multiplier] *= 1.3
end end
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:BLAZE, Battle::AbilityEffects::DamageCalcFromUser.add(:BLAZE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.hp <= user.totalhp / 3 && type == :FIRE if user.hp <= user.totalhp / 3 && type == :FIRE
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1227,25 +1227,25 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:BLAZE,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:DEFEATIST, Battle::AbilityEffects::DamageCalcFromUser.add(:DEFEATIST,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] /= 2 if user.hp <= user.totalhp / 2 mults[:attack_multiplier] /= 2 if user.hp <= user.totalhp / 2
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:DRAGONSMAW, Battle::AbilityEffects::DamageCalcFromUser.add(:DRAGONSMAW,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.5 if type == :DRAGON mults[:attack_multiplier] *= 1.5 if type == :DRAGON
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:FLAREBOOST, Battle::AbilityEffects::DamageCalcFromUser.add(:FLAREBOOST,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.5 if user.burned? && move.specialMove? mults[:power_multiplier] *= 1.5 if user.burned? && move.specialMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:FLASHFIRE, Battle::AbilityEffects::DamageCalcFromUser.add(:FLASHFIRE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.effects[PBEffects::FlashFire] && type == :FIRE if user.effects[PBEffects::FlashFire] && type == :FIRE
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1253,7 +1253,7 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:FLASHFIRE,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:FLOWERGIFT, Battle::AbilityEffects::DamageCalcFromUser.add(:FLOWERGIFT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if move.physicalMove? && [:Sun, :HarshSun].include?(user.effectiveWeather) if move.physicalMove? && [:Sun, :HarshSun].include?(user.effectiveWeather)
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1261,13 +1261,13 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:FLOWERGIFT,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:GORILLATACTICS, Battle::AbilityEffects::DamageCalcFromUser.add(:GORILLATACTICS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.5 if move.physicalMove? mults[:attack_multiplier] *= 1.5 if move.physicalMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:GUTS, Battle::AbilityEffects::DamageCalcFromUser.add(:GUTS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.pbHasAnyStatus? && move.physicalMove? if user.pbHasAnyStatus? && move.physicalMove?
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1275,7 +1275,7 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:GUTS,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:HUGEPOWER, Battle::AbilityEffects::DamageCalcFromUser.add(:HUGEPOWER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 2 if move.physicalMove? mults[:attack_multiplier] *= 2 if move.physicalMove?
} }
) )
@@ -1283,25 +1283,25 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:HUGEPOWER,
Battle::AbilityEffects::DamageCalcFromUser.copy(:HUGEPOWER, :PUREPOWER) Battle::AbilityEffects::DamageCalcFromUser.copy(:HUGEPOWER, :PUREPOWER)
Battle::AbilityEffects::DamageCalcFromUser.add(:HUSTLE, Battle::AbilityEffects::DamageCalcFromUser.add(:HUSTLE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.5 if move.physicalMove? mults[:attack_multiplier] *= 1.5 if move.physicalMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:IRONFIST, Battle::AbilityEffects::DamageCalcFromUser.add(:IRONFIST,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if move.punchingMove? mults[:power_multiplier] *= 1.2 if move.punchingMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:MEGALAUNCHER, Battle::AbilityEffects::DamageCalcFromUser.add(:MEGALAUNCHER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.5 if move.pulseMove? mults[:power_multiplier] *= 1.5 if move.pulseMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:MINUS, Battle::AbilityEffects::DamageCalcFromUser.add(:MINUS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
next if !move.specialMove? next if !move.specialMove?
if user.allAllies.any? { |b| b.hasActiveAbility?([:MINUS, :PLUS]) } if user.allAllies.any? { |b| b.hasActiveAbility?([:MINUS, :PLUS]) }
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
@@ -1312,7 +1312,7 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:MINUS,
Battle::AbilityEffects::DamageCalcFromUser.copy(:MINUS, :PLUS) Battle::AbilityEffects::DamageCalcFromUser.copy(:MINUS, :PLUS)
Battle::AbilityEffects::DamageCalcFromUser.add(:NEUROFORCE, Battle::AbilityEffects::DamageCalcFromUser.add(:NEUROFORCE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if Effectiveness.super_effective?(target.damageState.typeMod) if Effectiveness.super_effective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 1.25 mults[:final_damage_multiplier] *= 1.25
end end
@@ -1320,7 +1320,7 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:NEUROFORCE,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:OVERGROW, Battle::AbilityEffects::DamageCalcFromUser.add(:OVERGROW,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.hp <= user.totalhp / 3 && type == :GRASS if user.hp <= user.totalhp / 3 && type == :GRASS
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1328,52 +1328,52 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:OVERGROW,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:PUNKROCK, Battle::AbilityEffects::DamageCalcFromUser.add(:PUNKROCK,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.3 if move.soundMove? mults[:attack_multiplier] *= 1.3 if move.soundMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:RECKLESS, Battle::AbilityEffects::DamageCalcFromUser.add(:RECKLESS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if move.recoilMove? mults[:power_multiplier] *= 1.2 if move.recoilMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:RIVALRY, Battle::AbilityEffects::DamageCalcFromUser.add(:RIVALRY,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.gender != 2 && target.gender != 2 if user.gender != 2 && target.gender != 2
if user.gender == target.gender if user.gender == target.gender
mults[:base_damage_multiplier] *= 1.25 mults[:power_multiplier] *= 1.25
else else
mults[:base_damage_multiplier] *= 0.75 mults[:power_multiplier] *= 0.75
end end
end end
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SANDFORCE, Battle::AbilityEffects::DamageCalcFromUser.add(:SANDFORCE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.effectiveWeather == :Sandstorm && if user.effectiveWeather == :Sandstorm &&
[:ROCK, :GROUND, :STEEL].include?(type) [:ROCK, :GROUND, :STEEL].include?(type)
mults[:base_damage_multiplier] *= 1.3 mults[:power_multiplier] *= 1.3
end end
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SHEERFORCE, Battle::AbilityEffects::DamageCalcFromUser.add(:SHEERFORCE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.3 if move.addlEffect > 0 mults[:power_multiplier] *= 1.3 if move.addlEffect > 0
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SLOWSTART, Battle::AbilityEffects::DamageCalcFromUser.add(:SLOWSTART,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] /= 2 if user.effects[PBEffects::SlowStart] > 0 && move.physicalMove? mults[:attack_multiplier] /= 2 if user.effects[PBEffects::SlowStart] > 0 && move.physicalMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SOLARPOWER, Battle::AbilityEffects::DamageCalcFromUser.add(:SOLARPOWER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if move.specialMove? && [:Sun, :HarshSun].include?(user.effectiveWeather) if move.specialMove? && [:Sun, :HarshSun].include?(user.effectiveWeather)
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1381,37 +1381,37 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:SOLARPOWER,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SNIPER, Battle::AbilityEffects::DamageCalcFromUser.add(:SNIPER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 1.5 if target.damageState.critical mults[:final_damage_multiplier] *= 1.5 if target.damageState.critical
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:STAKEOUT, Battle::AbilityEffects::DamageCalcFromUser.add(:STAKEOUT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 2 if target.battle.choices[target.index][0] == :SwitchOut mults[:attack_multiplier] *= 2 if target.battle.choices[target.index][0] == :SwitchOut
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:STEELWORKER, Battle::AbilityEffects::DamageCalcFromUser.add(:STEELWORKER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.5 if type == :STEEL mults[:attack_multiplier] *= 1.5 if type == :STEEL
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:STEELYSPIRIT, Battle::AbilityEffects::DamageCalcFromUser.add(:STEELYSPIRIT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 1.5 if type == :STEEL mults[:final_damage_multiplier] *= 1.5 if type == :STEEL
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:STRONGJAW, Battle::AbilityEffects::DamageCalcFromUser.add(:STRONGJAW,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.5 if move.bitingMove? mults[:power_multiplier] *= 1.5 if move.bitingMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:SWARM, Battle::AbilityEffects::DamageCalcFromUser.add(:SWARM,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.hp <= user.totalhp / 3 && type == :BUG if user.hp <= user.totalhp / 3 && type == :BUG
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1419,22 +1419,22 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:SWARM,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TECHNICIAN, Battle::AbilityEffects::DamageCalcFromUser.add(:TECHNICIAN,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.index != target.index && move && move.id != :STRUGGLE && if user.index != target.index && move && move.id != :STRUGGLE &&
baseDmg * mults[:base_damage_multiplier] <= 60 power * mults[:power_multiplier] <= 60
mults[:base_damage_multiplier] *= 1.5 mults[:power_multiplier] *= 1.5
end end
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TINTEDLENS, Battle::AbilityEffects::DamageCalcFromUser.add(:TINTEDLENS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 2 if Effectiveness.resistant?(target.damageState.typeMod) mults[:final_damage_multiplier] *= 2 if Effectiveness.resistant?(target.damageState.typeMod)
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TORRENT, Battle::AbilityEffects::DamageCalcFromUser.add(:TORRENT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.hp <= user.totalhp / 3 && type == :WATER if user.hp <= user.totalhp / 3 && type == :WATER
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1442,27 +1442,27 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:TORRENT,
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TOUGHCLAWS, Battle::AbilityEffects::DamageCalcFromUser.add(:TOUGHCLAWS,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 4 / 3.0 if move.contactMove? mults[:power_multiplier] *= 4 / 3.0 if move.contactMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TOXICBOOST, Battle::AbilityEffects::DamageCalcFromUser.add(:TOXICBOOST,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if user.poisoned? && move.physicalMove? if user.poisoned? && move.physicalMove?
mults[:base_damage_multiplier] *= 1.5 mults[:power_multiplier] *= 1.5
end end
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:TRANSISTOR, Battle::AbilityEffects::DamageCalcFromUser.add(:TRANSISTOR,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 1.5 if type == :ELECTRIC mults[:attack_multiplier] *= 1.5 if type == :ELECTRIC
} }
) )
Battle::AbilityEffects::DamageCalcFromUser.add(:WATERBUBBLE, Battle::AbilityEffects::DamageCalcFromUser.add(:WATERBUBBLE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 2 if type == :WATER mults[:attack_multiplier] *= 2 if type == :WATER
} }
) )
@@ -1472,14 +1472,14 @@ Battle::AbilityEffects::DamageCalcFromUser.add(:WATERBUBBLE,
#=============================================================================== #===============================================================================
Battle::AbilityEffects::DamageCalcFromAlly.add(:BATTERY, Battle::AbilityEffects::DamageCalcFromAlly.add(:BATTERY,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
next if !move.specialMove? next if !move.specialMove?
mults[:final_damage_multiplier] *= 1.3 mults[:final_damage_multiplier] *= 1.3
} }
) )
Battle::AbilityEffects::DamageCalcFromAlly.add(:FLOWERGIFT, Battle::AbilityEffects::DamageCalcFromAlly.add(:FLOWERGIFT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if move.physicalMove? && [:Sun, :HarshSun].include?(user.effectiveWeather) if move.physicalMove? && [:Sun, :HarshSun].include?(user.effectiveWeather)
mults[:attack_multiplier] *= 1.5 mults[:attack_multiplier] *= 1.5
end end
@@ -1487,13 +1487,13 @@ Battle::AbilityEffects::DamageCalcFromAlly.add(:FLOWERGIFT,
) )
Battle::AbilityEffects::DamageCalcFromAlly.add(:POWERSPOT, Battle::AbilityEffects::DamageCalcFromAlly.add(:POWERSPOT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 1.3 mults[:final_damage_multiplier] *= 1.3
} }
) )
Battle::AbilityEffects::DamageCalcFromAlly.add(:STEELYSPIRIT, Battle::AbilityEffects::DamageCalcFromAlly.add(:STEELYSPIRIT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 1.5 if type == :STEEL mults[:final_damage_multiplier] *= 1.5 if type == :STEEL
} }
) )
@@ -1503,13 +1503,13 @@ Battle::AbilityEffects::DamageCalcFromAlly.add(:STEELYSPIRIT,
#=============================================================================== #===============================================================================
Battle::AbilityEffects::DamageCalcFromTarget.add(:DRYSKIN, Battle::AbilityEffects::DamageCalcFromTarget.add(:DRYSKIN,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.25 if type == :FIRE mults[:power_multiplier] *= 1.25 if type == :FIRE
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:FILTER, Battle::AbilityEffects::DamageCalcFromTarget.add(:FILTER,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if Effectiveness.super_effective?(target.damageState.typeMod) if Effectiveness.super_effective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 0.75 mults[:final_damage_multiplier] *= 0.75
end end
@@ -1519,7 +1519,7 @@ Battle::AbilityEffects::DamageCalcFromTarget.add(:FILTER,
Battle::AbilityEffects::DamageCalcFromTarget.copy(:FILTER, :SOLIDROCK) Battle::AbilityEffects::DamageCalcFromTarget.copy(:FILTER, :SOLIDROCK)
Battle::AbilityEffects::DamageCalcFromTarget.add(:FLOWERGIFT, Battle::AbilityEffects::DamageCalcFromTarget.add(:FLOWERGIFT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if move.specialMove? && [:Sun, :HarshSun].include?(target.effectiveWeather) if move.specialMove? && [:Sun, :HarshSun].include?(target.effectiveWeather)
mults[:defense_multiplier] *= 1.5 mults[:defense_multiplier] *= 1.5
end end
@@ -1527,39 +1527,39 @@ Battle::AbilityEffects::DamageCalcFromTarget.add(:FLOWERGIFT,
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:FLUFFY, Battle::AbilityEffects::DamageCalcFromTarget.add(:FLUFFY,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 2 if move.calcType == :FIRE mults[:final_damage_multiplier] *= 2 if move.calcType == :FIRE
mults[:final_damage_multiplier] /= 2 if move.pbContactMove?(user) mults[:final_damage_multiplier] /= 2 if move.pbContactMove?(user)
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:FURCOAT, Battle::AbilityEffects::DamageCalcFromTarget.add(:FURCOAT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:defense_multiplier] *= 2 if move.physicalMove? || mults[:defense_multiplier] *= 2 if move.physicalMove? ||
move.function == "UseTargetDefenseInsteadOfTargetSpDef" # Psyshock move.function == "UseTargetDefenseInsteadOfTargetSpDef" # Psyshock
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:GRASSPELT, Battle::AbilityEffects::DamageCalcFromTarget.add(:GRASSPELT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:defense_multiplier] *= 1.5 if user.battle.field.terrain == :Grassy mults[:defense_multiplier] *= 1.5 if user.battle.field.terrain == :Grassy
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:HEATPROOF, Battle::AbilityEffects::DamageCalcFromTarget.add(:HEATPROOF,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] /= 2 if type == :FIRE mults[:power_multiplier] /= 2 if type == :FIRE
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:ICESCALES, Battle::AbilityEffects::DamageCalcFromTarget.add(:ICESCALES,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] /= 2 if move.specialMove? mults[:final_damage_multiplier] /= 2 if move.specialMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:MARVELSCALE, Battle::AbilityEffects::DamageCalcFromTarget.add(:MARVELSCALE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if target.pbHasAnyStatus? && move.physicalMove? if target.pbHasAnyStatus? && move.physicalMove?
mults[:defense_multiplier] *= 1.5 mults[:defense_multiplier] *= 1.5
end end
@@ -1567,25 +1567,25 @@ Battle::AbilityEffects::DamageCalcFromTarget.add(:MARVELSCALE,
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:MULTISCALE, Battle::AbilityEffects::DamageCalcFromTarget.add(:MULTISCALE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] /= 2 if target.hp == target.totalhp mults[:final_damage_multiplier] /= 2 if target.hp == target.totalhp
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:PUNKROCK, Battle::AbilityEffects::DamageCalcFromTarget.add(:PUNKROCK,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] /= 2 if move.soundMove? mults[:final_damage_multiplier] /= 2 if move.soundMove?
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:THICKFAT, Battle::AbilityEffects::DamageCalcFromTarget.add(:THICKFAT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:base_damage_multiplier] /= 2 if [:FIRE, :ICE].include?(type) mults[:power_multiplier] /= 2 if [:FIRE, :ICE].include?(type)
} }
) )
Battle::AbilityEffects::DamageCalcFromTarget.add(:WATERBUBBLE, Battle::AbilityEffects::DamageCalcFromTarget.add(:WATERBUBBLE,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] /= 2 if type == :FIRE mults[:final_damage_multiplier] /= 2 if type == :FIRE
} }
) )
@@ -1595,7 +1595,7 @@ Battle::AbilityEffects::DamageCalcFromTarget.add(:WATERBUBBLE,
#=============================================================================== #===============================================================================
Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:PRISMARMOR, Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:PRISMARMOR,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if Effectiveness.super_effective?(target.damageState.typeMod) if Effectiveness.super_effective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 0.75 mults[:final_damage_multiplier] *= 0.75
end end
@@ -1603,7 +1603,7 @@ Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:PRISMARMOR,
) )
Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:SHADOWSHIELD, Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:SHADOWSHIELD,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] /= 2 if target.hp == target.totalhp mults[:final_damage_multiplier] /= 2 if target.hp == target.totalhp
} }
) )
@@ -1613,7 +1613,7 @@ Battle::AbilityEffects::DamageCalcFromTargetNonIgnorable.add(:SHADOWSHIELD,
#=============================================================================== #===============================================================================
Battle::AbilityEffects::DamageCalcFromTargetAlly.add(:FLOWERGIFT, Battle::AbilityEffects::DamageCalcFromTargetAlly.add(:FLOWERGIFT,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
if move.specialMove? && [:Sun, :HarshSun].include?(target.effectiveWeather) if move.specialMove? && [:Sun, :HarshSun].include?(target.effectiveWeather)
mults[:defense_multiplier] *= 1.5 mults[:defense_multiplier] *= 1.5
end end
@@ -1621,7 +1621,7 @@ Battle::AbilityEffects::DamageCalcFromTargetAlly.add(:FLOWERGIFT,
) )
Battle::AbilityEffects::DamageCalcFromTargetAlly.add(:FRIENDGUARD, Battle::AbilityEffects::DamageCalcFromTargetAlly.add(:FRIENDGUARD,
proc { |ability, user, target, move, mults, baseDmg, type| proc { |ability, user, target, move, mults, power, type|
mults[:final_damage_multiplier] *= 0.75 mults[:final_damage_multiplier] *= 0.75
} }
) )
@@ -2739,7 +2739,7 @@ Battle::AbilityEffects::OnSwitchIn.add(:FOREWARN,
forewarnMoves = [] forewarnMoves = []
battle.allOtherSideBattlers(battler.index).each do |b| battle.allOtherSideBattlers(battler.index).each do |b|
b.eachMove do |m| b.eachMove do |m|
power = m.baseDamage power = m.power
power = 160 if ["OHKO", "OHKOIce", "OHKOHitsUndergroundTarget"].include?(m.function) power = 160 if ["OHKO", "OHKOIce", "OHKOHitsUndergroundTarget"].include?(m.function)
power = 150 if ["PowerHigherWithUserHP"].include?(m.function) # Eruption power = 150 if ["PowerHigherWithUserHP"].include?(m.function) # Eruption
# Counter, Mirror Coat, Metal Burst # Counter, Mirror Coat, Metal Burst

204
Data/Scripts/011_Battle/006_Other battle code/009_Battle_ItemEffects.rb
View File

@@ -109,12 +109,12 @@ module Battle::ItemEffects
#============================================================================= #=============================================================================
def self.triggerDamageCalcFromUser(item, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromUser(item, user, target, move, mults, power, type)
DamageCalcFromUser.trigger(item, user, target, move, mults, base_damage, type) DamageCalcFromUser.trigger(item, user, target, move, mults, power, type)
end end
def self.triggerDamageCalcFromTarget(item, user, target, move, mults, base_damage, type) def self.triggerDamageCalcFromTarget(item, user, target, move, mults, power, type)
DamageCalcFromTarget.trigger(item, user, target, move, mults, base_damage, type) DamageCalcFromTarget.trigger(item, user, target, move, mults, power, type)
end end
def self.triggerCriticalCalcFromUser(item, user, target, crit_stage) def self.triggerCriticalCalcFromUser(item, user, target, crit_stage)
@@ -724,63 +724,63 @@ Battle::ItemEffects::AccuracyCalcFromTarget.copy(:BRIGHTPOWDER, :LAXINCENSE)
#=============================================================================== #===============================================================================
Battle::ItemEffects::DamageCalcFromUser.add(:ADAMANTORB, Battle::ItemEffects::DamageCalcFromUser.add(:ADAMANTORB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if user.isSpecies?(:DIALGA) && [:DRAGON, :STEEL].include?(type) if user.isSpecies?(:DIALGA) && [:DRAGON, :STEEL].include?(type)
mults[:base_damage_multiplier] *= 1.2 mults[:power_multiplier] *= 1.2
end end
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:BLACKBELT, Battle::ItemEffects::DamageCalcFromUser.add(:BLACKBELT,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :FIGHTING mults[:power_multiplier] *= 1.2 if type == :FIGHTING
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:BLACKBELT, :FISTPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:BLACKBELT, :FISTPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:BLACKGLASSES, Battle::ItemEffects::DamageCalcFromUser.add(:BLACKGLASSES,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :DARK mults[:power_multiplier] *= 1.2 if type == :DARK
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:BLACKGLASSES, :DREADPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:BLACKGLASSES, :DREADPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:BUGGEM, Battle::ItemEffects::DamageCalcFromUser.add(:BUGGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:BUG, move, type, mults) user.pbMoveTypePoweringUpGem(:BUG, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:CHARCOAL, Battle::ItemEffects::DamageCalcFromUser.add(:CHARCOAL,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :FIRE mults[:power_multiplier] *= 1.2 if type == :FIRE
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:CHARCOAL, :FLAMEPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:CHARCOAL, :FLAMEPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:CHOICEBAND, Battle::ItemEffects::DamageCalcFromUser.add(:CHOICEBAND,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.5 if move.physicalMove? mults[:power_multiplier] *= 1.5 if move.physicalMove?
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:CHOICESPECS, Battle::ItemEffects::DamageCalcFromUser.add(:CHOICESPECS,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.5 if move.specialMove? mults[:power_multiplier] *= 1.5 if move.specialMove?
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:DARKGEM, Battle::ItemEffects::DamageCalcFromUser.add(:DARKGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:DARK, move, type, mults) user.pbMoveTypePoweringUpGem(:DARK, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:DEEPSEATOOTH, Battle::ItemEffects::DamageCalcFromUser.add(:DEEPSEATOOTH,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if user.isSpecies?(:CLAMPERL) && move.specialMove? if user.isSpecies?(:CLAMPERL) && move.specialMove?
mults[:attack_multiplier] *= 2 mults[:attack_multiplier] *= 2
end end
@@ -788,27 +788,27 @@ Battle::ItemEffects::DamageCalcFromUser.add(:DEEPSEATOOTH,
) )
Battle::ItemEffects::DamageCalcFromUser.add(:DRAGONFANG, Battle::ItemEffects::DamageCalcFromUser.add(:DRAGONFANG,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :DRAGON mults[:power_multiplier] *= 1.2 if type == :DRAGON
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:DRAGONFANG, :DRACOPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:DRAGONFANG, :DRACOPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:DRAGONGEM, Battle::ItemEffects::DamageCalcFromUser.add(:DRAGONGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:DRAGON, move, type, mults) user.pbMoveTypePoweringUpGem(:DRAGON, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:ELECTRICGEM, Battle::ItemEffects::DamageCalcFromUser.add(:ELECTRICGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:ELECTRIC, move, type, mults) user.pbMoveTypePoweringUpGem(:ELECTRIC, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:EXPERTBELT, Battle::ItemEffects::DamageCalcFromUser.add(:EXPERTBELT,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if Effectiveness.super_effective?(target.damageState.typeMod) if Effectiveness.super_effective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 1.2 mults[:final_damage_multiplier] *= 1.2
end end
@@ -816,71 +816,71 @@ Battle::ItemEffects::DamageCalcFromUser.add(:EXPERTBELT,
) )
Battle::ItemEffects::DamageCalcFromUser.add(:FAIRYGEM, Battle::ItemEffects::DamageCalcFromUser.add(:FAIRYGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:FAIRY, move, type, mults) user.pbMoveTypePoweringUpGem(:FAIRY, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:FIGHTINGGEM, Battle::ItemEffects::DamageCalcFromUser.add(:FIGHTINGGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:FIGHTING, move, type, mults) user.pbMoveTypePoweringUpGem(:FIGHTING, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:FIREGEM, Battle::ItemEffects::DamageCalcFromUser.add(:FIREGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:FIRE, move, type, mults) user.pbMoveTypePoweringUpGem(:FIRE, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:FLYINGGEM, Battle::ItemEffects::DamageCalcFromUser.add(:FLYINGGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:FLYING, move, type, mults) user.pbMoveTypePoweringUpGem(:FLYING, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:GHOSTGEM, Battle::ItemEffects::DamageCalcFromUser.add(:GHOSTGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:GHOST, move, type, mults) user.pbMoveTypePoweringUpGem(:GHOST, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:GRASSGEM, Battle::ItemEffects::DamageCalcFromUser.add(:GRASSGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:GRASS, move, type, mults) user.pbMoveTypePoweringUpGem(:GRASS, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:GRISEOUSORB, Battle::ItemEffects::DamageCalcFromUser.add(:GRISEOUSORB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if user.isSpecies?(:GIRATINA) && [:DRAGON, :GHOST].include?(type) if user.isSpecies?(:GIRATINA) && [:DRAGON, :GHOST].include?(type)
mults[:base_damage_multiplier] *= 1.2 mults[:power_multiplier] *= 1.2
end end
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:GROUNDGEM, Battle::ItemEffects::DamageCalcFromUser.add(:GROUNDGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:GROUND, move, type, mults) user.pbMoveTypePoweringUpGem(:GROUND, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:HARDSTONE, Battle::ItemEffects::DamageCalcFromUser.add(:HARDSTONE,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :ROCK mults[:power_multiplier] *= 1.2 if type == :ROCK
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:HARDSTONE, :STONEPLATE, :ROCKINCENSE) Battle::ItemEffects::DamageCalcFromUser.copy(:HARDSTONE, :STONEPLATE, :ROCKINCENSE)
Battle::ItemEffects::DamageCalcFromUser.add(:ICEGEM, Battle::ItemEffects::DamageCalcFromUser.add(:ICEGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:ICE, move, type, mults) user.pbMoveTypePoweringUpGem(:ICE, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:LIFEORB, Battle::ItemEffects::DamageCalcFromUser.add(:LIFEORB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if !move.is_a?(Battle::Move::Confusion) if !move.is_a?(Battle::Move::Confusion)
mults[:final_damage_multiplier] *= 1.3 mults[:final_damage_multiplier] *= 1.3
end end
@@ -888,142 +888,142 @@ Battle::ItemEffects::DamageCalcFromUser.add(:LIFEORB,
) )
Battle::ItemEffects::DamageCalcFromUser.add(:LIGHTBALL, Battle::ItemEffects::DamageCalcFromUser.add(:LIGHTBALL,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:attack_multiplier] *= 2 if user.isSpecies?(:PIKACHU) mults[:attack_multiplier] *= 2 if user.isSpecies?(:PIKACHU)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:LUSTROUSORB, Battle::ItemEffects::DamageCalcFromUser.add(:LUSTROUSORB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if user.isSpecies?(:PALKIA) && [:DRAGON, :WATER].include?(type) if user.isSpecies?(:PALKIA) && [:DRAGON, :WATER].include?(type)
mults[:base_damage_multiplier] *= 1.2 mults[:power_multiplier] *= 1.2
end end
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:MAGNET, Battle::ItemEffects::DamageCalcFromUser.add(:MAGNET,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :ELECTRIC mults[:power_multiplier] *= 1.2 if type == :ELECTRIC
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:MAGNET, :ZAPPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:MAGNET, :ZAPPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:METALCOAT, Battle::ItemEffects::DamageCalcFromUser.add(:METALCOAT,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :STEEL mults[:power_multiplier] *= 1.2 if type == :STEEL
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:METALCOAT, :IRONPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:METALCOAT, :IRONPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:METRONOME, Battle::ItemEffects::DamageCalcFromUser.add(:METRONOME,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
met = 1 + (0.2 * [user.effects[PBEffects::Metronome], 5].min) met = 1 + (0.2 * [user.effects[PBEffects::Metronome], 5].min)
mults[:final_damage_multiplier] *= met mults[:final_damage_multiplier] *= met
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:MIRACLESEED, Battle::ItemEffects::DamageCalcFromUser.add(:MIRACLESEED,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :GRASS mults[:power_multiplier] *= 1.2 if type == :GRASS
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:MIRACLESEED, :MEADOWPLATE, :ROSEINCENSE) Battle::ItemEffects::DamageCalcFromUser.copy(:MIRACLESEED, :MEADOWPLATE, :ROSEINCENSE)
Battle::ItemEffects::DamageCalcFromUser.add(:MUSCLEBAND, Battle::ItemEffects::DamageCalcFromUser.add(:MUSCLEBAND,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.1 if move.physicalMove? mults[:power_multiplier] *= 1.1 if move.physicalMove?
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:MYSTICWATER, Battle::ItemEffects::DamageCalcFromUser.add(:MYSTICWATER,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :WATER mults[:power_multiplier] *= 1.2 if type == :WATER
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:MYSTICWATER, :SPLASHPLATE, :SEAINCENSE, :WAVEINCENSE) Battle::ItemEffects::DamageCalcFromUser.copy(:MYSTICWATER, :SPLASHPLATE, :SEAINCENSE, :WAVEINCENSE)
Battle::ItemEffects::DamageCalcFromUser.add(:NEVERMELTICE, Battle::ItemEffects::DamageCalcFromUser.add(:NEVERMELTICE,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :ICE mults[:power_multiplier] *= 1.2 if type == :ICE
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:NEVERMELTICE, :ICICLEPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:NEVERMELTICE, :ICICLEPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:NORMALGEM, Battle::ItemEffects::DamageCalcFromUser.add(:NORMALGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:NORMAL, move, type, mults) user.pbMoveTypePoweringUpGem(:NORMAL, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:PIXIEPLATE, Battle::ItemEffects::DamageCalcFromUser.add(:PIXIEPLATE,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :FAIRY mults[:power_multiplier] *= 1.2 if type == :FAIRY
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:POISONBARB, Battle::ItemEffects::DamageCalcFromUser.add(:POISONBARB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :POISON mults[:power_multiplier] *= 1.2 if type == :POISON
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:POISONBARB, :TOXICPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:POISONBARB, :TOXICPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:POISONGEM, Battle::ItemEffects::DamageCalcFromUser.add(:POISONGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:POISON, move, type, mults) user.pbMoveTypePoweringUpGem(:POISON, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:PSYCHICGEM, Battle::ItemEffects::DamageCalcFromUser.add(:PSYCHICGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:PSYCHIC, move, type, mults) user.pbMoveTypePoweringUpGem(:PSYCHIC, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:ROCKGEM, Battle::ItemEffects::DamageCalcFromUser.add(:ROCKGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:ROCK, move, type, mults) user.pbMoveTypePoweringUpGem(:ROCK, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:SHARPBEAK, Battle::ItemEffects::DamageCalcFromUser.add(:SHARPBEAK,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :FLYING mults[:power_multiplier] *= 1.2 if type == :FLYING
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:SHARPBEAK, :SKYPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:SHARPBEAK, :SKYPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:SILKSCARF, Battle::ItemEffects::DamageCalcFromUser.add(:SILKSCARF,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :NORMAL mults[:power_multiplier] *= 1.2 if type == :NORMAL
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:SILVERPOWDER, Battle::ItemEffects::DamageCalcFromUser.add(:SILVERPOWDER,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :BUG mults[:power_multiplier] *= 1.2 if type == :BUG
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:SILVERPOWDER, :INSECTPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:SILVERPOWDER, :INSECTPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:SOFTSAND, Battle::ItemEffects::DamageCalcFromUser.add(:SOFTSAND,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :GROUND mults[:power_multiplier] *= 1.2 if type == :GROUND
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:SOFTSAND, :EARTHPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:SOFTSAND, :EARTHPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:SOULDEW, Battle::ItemEffects::DamageCalcFromUser.add(:SOULDEW,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
next if !user.isSpecies?(:LATIAS) && !user.isSpecies?(:LATIOS) next if !user.isSpecies?(:LATIAS) && !user.isSpecies?(:LATIOS)
if Settings::SOUL_DEW_POWERS_UP_TYPES if Settings::SOUL_DEW_POWERS_UP_TYPES
mults[:final_damage_multiplier] *= 1.2 if [:DRAGON, :PSYCHIC].include?(type) mults[:final_damage_multiplier] *= 1.2 if [:DRAGON, :PSYCHIC].include?(type)
@@ -1034,21 +1034,21 @@ Battle::ItemEffects::DamageCalcFromUser.add(:SOULDEW,
) )
Battle::ItemEffects::DamageCalcFromUser.add(:SPELLTAG, Battle::ItemEffects::DamageCalcFromUser.add(:SPELLTAG,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :GHOST mults[:power_multiplier] *= 1.2 if type == :GHOST
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:SPELLTAG, :SPOOKYPLATE) Battle::ItemEffects::DamageCalcFromUser.copy(:SPELLTAG, :SPOOKYPLATE)
Battle::ItemEffects::DamageCalcFromUser.add(:STEELGEM, Battle::ItemEffects::DamageCalcFromUser.add(:STEELGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:STEEL, move, type, mults) user.pbMoveTypePoweringUpGem(:STEEL, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:THICKCLUB, Battle::ItemEffects::DamageCalcFromUser.add(:THICKCLUB,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if (user.isSpecies?(:CUBONE) || user.isSpecies?(:MAROWAK)) && move.physicalMove? if (user.isSpecies?(:CUBONE) || user.isSpecies?(:MAROWAK)) && move.physicalMove?
mults[:attack_multiplier] *= 2 mults[:attack_multiplier] *= 2
end end
@@ -1056,22 +1056,22 @@ Battle::ItemEffects::DamageCalcFromUser.add(:THICKCLUB,
) )
Battle::ItemEffects::DamageCalcFromUser.add(:TWISTEDSPOON, Battle::ItemEffects::DamageCalcFromUser.add(:TWISTEDSPOON,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.2 if type == :PSYCHIC mults[:power_multiplier] *= 1.2 if type == :PSYCHIC
} }
) )
Battle::ItemEffects::DamageCalcFromUser.copy(:TWISTEDSPOON, :MINDPLATE, :ODDINCENSE) Battle::ItemEffects::DamageCalcFromUser.copy(:TWISTEDSPOON, :MINDPLATE, :ODDINCENSE)
Battle::ItemEffects::DamageCalcFromUser.add(:WATERGEM, Battle::ItemEffects::DamageCalcFromUser.add(:WATERGEM,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
user.pbMoveTypePoweringUpGem(:WATER, move, type, mults) user.pbMoveTypePoweringUpGem(:WATER, move, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromUser.add(:WISEGLASSES, Battle::ItemEffects::DamageCalcFromUser.add(:WISEGLASSES,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:base_damage_multiplier] *= 1.1 if move.specialMove? mults[:power_multiplier] *= 1.1 if move.specialMove?
} }
) )
@@ -1083,49 +1083,49 @@ Battle::ItemEffects::DamageCalcFromUser.add(:WISEGLASSES,
#=============================================================================== #===============================================================================
Battle::ItemEffects::DamageCalcFromTarget.add(:ASSAULTVEST, Battle::ItemEffects::DamageCalcFromTarget.add(:ASSAULTVEST,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
mults[:defense_multiplier] *= 1.5 if move.specialMove? mults[:defense_multiplier] *= 1.5 if move.specialMove?
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:BABIRIBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:BABIRIBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:STEEL, type, mults) target.pbMoveTypeWeakeningBerry(:STEEL, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:CHARTIBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:CHARTIBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:ROCK, type, mults) target.pbMoveTypeWeakeningBerry(:ROCK, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:CHILANBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:CHILANBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:NORMAL, type, mults) target.pbMoveTypeWeakeningBerry(:NORMAL, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:CHOPLEBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:CHOPLEBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:FIGHTING, type, mults) target.pbMoveTypeWeakeningBerry(:FIGHTING, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:COBABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:COBABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:FLYING, type, mults) target.pbMoveTypeWeakeningBerry(:FLYING, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:COLBURBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:COLBURBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:DARK, type, mults) target.pbMoveTypeWeakeningBerry(:DARK, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:DEEPSEASCALE, Battle::ItemEffects::DamageCalcFromTarget.add(:DEEPSEASCALE,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if target.isSpecies?(:CLAMPERL) && move.specialMove? if target.isSpecies?(:CLAMPERL) && move.specialMove?
mults[:defense_multiplier] *= 2 mults[:defense_multiplier] *= 2
end end
@@ -1133,7 +1133,7 @@ Battle::ItemEffects::DamageCalcFromTarget.add(:DEEPSEASCALE,
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:EVIOLITE, Battle::ItemEffects::DamageCalcFromTarget.add(:EVIOLITE,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
# NOTE: Eviolite cares about whether the Pokémon itself can evolve, which # NOTE: Eviolite cares about whether the Pokémon itself can evolve, which
# means it also cares about the Pokémon's form. Some forms cannot # means it also cares about the Pokémon's form. Some forms cannot
# evolve even if the species generally can, and such forms are not # evolve even if the species generally can, and such forms are not
@@ -1145,25 +1145,25 @@ Battle::ItemEffects::DamageCalcFromTarget.add(:EVIOLITE,
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:HABANBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:HABANBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:DRAGON, type, mults) target.pbMoveTypeWeakeningBerry(:DRAGON, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:KASIBBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:KASIBBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:GHOST, type, mults) target.pbMoveTypeWeakeningBerry(:GHOST, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:KEBIABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:KEBIABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:POISON, type, mults) target.pbMoveTypeWeakeningBerry(:POISON, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:METALPOWDER, Battle::ItemEffects::DamageCalcFromTarget.add(:METALPOWDER,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
if target.isSpecies?(:DITTO) && !target.effects[PBEffects::Transform] if target.isSpecies?(:DITTO) && !target.effects[PBEffects::Transform]
mults[:defense_multiplier] *= 1.5 mults[:defense_multiplier] *= 1.5
end end
@@ -1171,43 +1171,43 @@ Battle::ItemEffects::DamageCalcFromTarget.add(:METALPOWDER,
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:OCCABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:OCCABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:FIRE, type, mults) target.pbMoveTypeWeakeningBerry(:FIRE, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:PASSHOBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:PASSHOBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:WATER, type, mults) target.pbMoveTypeWeakeningBerry(:WATER, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:PAYAPABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:PAYAPABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:PSYCHIC, type, mults) target.pbMoveTypeWeakeningBerry(:PSYCHIC, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:RINDOBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:RINDOBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:GRASS, type, mults) target.pbMoveTypeWeakeningBerry(:GRASS, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:ROSELIBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:ROSELIBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:FAIRY, type, mults) target.pbMoveTypeWeakeningBerry(:FAIRY, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:SHUCABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:SHUCABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:GROUND, type, mults) target.pbMoveTypeWeakeningBerry(:GROUND, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:SOULDEW, Battle::ItemEffects::DamageCalcFromTarget.add(:SOULDEW,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
next if Settings::SOUL_DEW_POWERS_UP_TYPES next if Settings::SOUL_DEW_POWERS_UP_TYPES
next if !target.isSpecies?(:LATIAS) && !target.isSpecies?(:LATIOS) next if !target.isSpecies?(:LATIAS) && !target.isSpecies?(:LATIOS)
if move.specialMove? && !user.battle.rules["souldewclause"] if move.specialMove? && !user.battle.rules["souldewclause"]
@@ -1217,19 +1217,19 @@ Battle::ItemEffects::DamageCalcFromTarget.add(:SOULDEW,
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:TANGABERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:TANGABERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:BUG, type, mults) target.pbMoveTypeWeakeningBerry(:BUG, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:WACANBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:WACANBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:ELECTRIC, type, mults) target.pbMoveTypeWeakeningBerry(:ELECTRIC, type, mults)
} }
) )
Battle::ItemEffects::DamageCalcFromTarget.add(:YACHEBERRY, Battle::ItemEffects::DamageCalcFromTarget.add(:YACHEBERRY,
proc { |item, user, target, move, mults, baseDmg, type| proc { |item, user, target, move, mults, power, type|
target.pbMoveTypeWeakeningBerry(:ICE, type, mults) target.pbMoveTypeWeakeningBerry(:ICE, type, mults)
} }
) )

100
Data/Scripts/012_Overworld/002_Battle triggering/001_Overworld_BattleStarting.rb
View File

@@ -739,103 +739,3 @@ def pbHoneyGather(pkmn)
return unless rand(100) < chance return unless rand(100) < chance
pkmn.item = :HONEY pkmn.item = :HONEY
end end
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This method is slated to be removed in v21.
def pbNewBattleScene
Deprecation.warn_method("pbNewBattleScene", "v21", "BattleCreationHelperMethods.create_battle_scene")
return BattleCreationHelperMethods.create_battle_scene
end
# @deprecated This method is slated to be removed in v21.
def pbPrepareBattle(battle)
Deprecation.warn_method("pbPrepareBattle", "v21", "BattleCreationHelperMethods.prepare_battle(battle)")
BattleCreationHelperMethods.prepare_battle(battle)
end
# @deprecated This method is slated to be removed in v21.
def pbWildBattleCore(*args)
Deprecation.warn_method("pbWildBattleCore", "v21", "WildBattle.start_core(species, level)")
return WildBattle.start_core(*args)
end
# @deprecated This method is slated to be removed in v21.
def pbWildBattle(species, level, outcomeVar = 1, canRun = true, canLose = false)
Deprecation.warn_method("pbWildBattle", "v21", "WildBattle.start(species, level)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("cannotRun") if !canRun
setBattleRule("canLose") if canLose
return WildBattle.start(species, level)
end
# @deprecated This method is slated to be removed in v21.
def pbDoubleWildBattle(species1, level1, species2, level2,
outcomeVar = 1, canRun = true, canLose = false)
Deprecation.warn_method("pbDoubleWildBattle", "v21", "WildBattle.start(pkmn1, pkmn2)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("cannotRun") if !canRun
setBattleRule("canLose") if canLose
setBattleRule("double")
return WildBattle.start(species1, level1, species2, level2)
end
# @deprecated This method is slated to be removed in v21.
def pbTripleWildBattle(species1, level1, species2, level2, species3, level3,
outcomeVar = 1, canRun = true, canLose = false)
Deprecation.warn_method("pbTripleWildBattle", "v21", "WildBattle.start(pkmn1, pkmn2, pkmn3)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("cannotRun") if !canRun
setBattleRule("canLose") if canLose
setBattleRule("triple")
return WildBattle.start(species1, level1, species2, level2, species3, level3)
end
# @deprecated This method is slated to be removed in v21.
def pbTrainerBattleCore(*args)
Deprecation.warn_method("pbTrainerBattleCore", "v21", "TrainerBattle.start_core(trainer_type, trainer_name, trainer_version)")
return TrainerBattle.start_core(*args)
end
# @deprecated This method is slated to be removed in v21.
def pbTrainerBattle(trainerID, trainerName, endSpeech = nil,
doubleBattle = false, trainerPartyID = 0, canLose = false, outcomeVar = 1)
Deprecation.warn_method("pbTrainerBattle", "v21", "TrainerBattle.start(trainer_type, trainer_name, trainer_version)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("canLose") if canLose
setBattleRule("double") if doubleBattle
return TrainerBattle.start(trainerID, trainerName, trainerPartyID)
end
# @deprecated This method is slated to be removed in v21.
def pbDoubleTrainerBattle(trainerID1, trainerName1, trainerPartyID1, endSpeech1,
trainerID2, trainerName2, trainerPartyID2 = 0, endSpeech2 = nil,
canLose = false, outcomeVar = 1)
Deprecation.warn_method("pbDoubleTrainerBattle", "v21", "TrainerBattle.start(trainer1, trainer2)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("canLose") if canLose
setBattleRule("double")
return TrainerBattle.start(trainerID1, trainerName1, trainerPartyID1,
trainerID2, trainerName2, trainerPartyID2)
end
# @deprecated This method is slated to be removed in v21.
def pbTripleTrainerBattle(trainerID1, trainerName1, trainerPartyID1, endSpeech1,
trainerID2, trainerName2, trainerPartyID2, endSpeech2,
trainerID3, trainerName3, trainerPartyID3 = 0, endSpeech3 = nil,
canLose = false, outcomeVar = 1)
Deprecation.warn_method("pbTripleTrainerBattle", "v21", "TrainerBattle.start(trainer1, trainer2, trainer3)")
setBattleRule("outcomeVar", outcomeVar) if outcomeVar != 1
setBattleRule("canLose") if canLose
setBattleRule("triple")
return TrainerBattle.start(trainerID1, trainerName1, trainerPartyID1,
trainerID2, trainerName2, trainerPartyID2,
trainerID3, trainerName3, trainerPartyID3)
end
# @deprecated This method is slated to be removed in v21.
def pbAfterBattle(outcome, can_lose)
Deprecation.warn_method("pbAfterBattle", "v21", "BattleCreationHelperMethods.after_battle(outcome, can_lose)")
BattleCreationHelperMethods.after_battle(outcome, can_lose)
end

4
Data/Scripts/012_Overworld/002_Overworld_Metadata.rb
View File

@@ -14,8 +14,8 @@ class PokemonGlobalMetadata
attr_accessor :stepcount attr_accessor :stepcount
attr_accessor :pcItemStorage attr_accessor :pcItemStorage
attr_accessor :mailbox attr_accessor :mailbox
attr_accessor :phoneNumbers # Deprecated attr_accessor :phoneNumbers # Deprecated - to be removed in v22
attr_accessor :phoneTime # Deprecated attr_accessor :phoneTime # Deprecated - to be removed in v22
attr_accessor :phone attr_accessor :phone
attr_accessor :partner attr_accessor :partner
attr_accessor :creditsPlayed attr_accessor :creditsPlayed

28
Data/Scripts/012_Overworld/004_Overworld_FieldMoves.rb
View File

@@ -357,20 +357,6 @@ def pbSurfacing
return false return false
end end
# @deprecated This method is slated to be removed in v21.
def pbTransferUnderwater(mapid, x, y, direction = $game_player.direction)
Deprecation.warn_method("pbTransferUnderwater", "v21", '"Transfer Player" event command')
pbFadeOutIn do
$game_temp.player_new_map_id = mapid
$game_temp.player_new_x = x
$game_temp.player_new_y = y
$game_temp.player_new_direction = direction
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
end
end
EventHandlers.add(:on_player_interact, :diving, EventHandlers.add(:on_player_interact, :diving,
proc { proc {
if $PokemonGlobal.diving if $PokemonGlobal.diving
@@ -755,20 +741,6 @@ def pbEndSurf(_xOffset, _yOffset)
return false return false
end end
# @deprecated This method is slated to be removed in v21.
def pbTransferSurfing(mapid, xcoord, ycoord, direction = $game_player.direction)
Deprecation.warn_method("pbTransferSurfing", "v21", '"Transfer Player" event command')
pbFadeOutIn do
$game_temp.player_new_map_id = mapid
$game_temp.player_new_x = xcoord
$game_temp.player_new_y = ycoord
$game_temp.player_new_direction = direction
$scene.transfer_player(false)
$game_map.autoplay
$game_map.refresh
end
end
EventHandlers.add(:on_player_interact, :start_surfing, EventHandlers.add(:on_player_interact, :start_surfing,
proc { proc {
next if $PokemonGlobal.surfing next if $PokemonGlobal.surfing

57
Data/Scripts/012_Overworld/007_Overworld_DayCare.rb
View File

@@ -562,60 +562,3 @@ EventHandlers.add(:on_player_step_taken, :update_day_care,
$PokemonGlobal.day_care.update_on_step_taken $PokemonGlobal.day_care.update_on_step_taken
} }
) )
#===============================================================================
# Deprecated methods
#===============================================================================
# @deprecated This method is slated to be removed in v21.
def pbDayCareDeposited
Deprecation.warn_method("pbDayCareDeposited", "v21", "DayCare.count")
return DayCare.count
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareGetDeposited(index, name_var, cost_var)
Deprecation.warn_method("pbDayCareGetDeposited", "v21", "DayCare.get_details(index, name_var, cost_var)")
DayCare.get_details(index, name_var, cost_var)
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareGetLevelGain(index, name_var, level_var)
Deprecation.warn_method("pbDayCareGetLevelGain", "v21", "DayCare.get_level_gain(index, name_var, level_var)")
DayCare.get_level_gain(index, name_var, level_var)
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareDeposit(party_index)
Deprecation.warn_method("pbDayCareDeposit", "v21", "DayCare.deposit(party_index)")
DayCare.deposit(party_index)
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareWithdraw(index)
Deprecation.warn_method("pbDayCareWithdraw", "v21", "DayCare.withdraw(index)")
DayCare.withdraw(index)
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareChoose(text, choice_var)
Deprecation.warn_method("pbDayCareChoose", "v21", "DayCare.choose(text, choice_var)")
DayCare.choose(text, choice_var)
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareGetCompatibility(compat_var)
Deprecation.warn_method("pbDayCareGetCompatibility", "v21", "DayCare.get_compatibility(compat_var)")
DayCare.get_compatibility(compat_var)
end
# @deprecated This method is slated to be removed in v21.
def pbEggGenerated?
Deprecation.warn_method("pbEggGenerated?", "v21", "DayCare.egg_generated?")
return DayCare.egg_generated?
end
# @deprecated This method is slated to be removed in v21.
def pbDayCareGenerateEgg
Deprecation.warn_method("pbDayCareGenerateEgg", "v21", "DayCare.collect_egg")
DayCare.collect_egg
end

4
Data/Scripts/013_Items/004_Item_Phone.rb
View File

@@ -587,7 +587,8 @@ EventHandlers.add(:on_frame_update, :phone_call_counter,
#=============================================================================== #===============================================================================
# Deprecated. # Deprecated.
#=============================================================================== #===============================================================================
# Called by events. # Called by events. Make your event look like this instead:
#
# @>Conditional Branch: Phone.can_add?(trainer_type, name, start_version) # @>Conditional Branch: Phone.can_add?(trainer_type, name, start_version)
# @>Text: Let me register you. # @>Text: Let me register you.
# @>Show Choices: Yes, No # @>Show Choices: Yes, No
@@ -602,6 +603,7 @@ EventHandlers.add(:on_frame_update, :phone_call_counter,
# : Branch End # : Branch End
# : Branch End # : Branch End
# @> # @>
#
# @deprecated This method is slated to be removed in v22. # @deprecated This method is slated to be removed in v22.
def pbPhoneRegisterBattle(message, event, trainer_type, name, versions_count) def pbPhoneRegisterBattle(message, event, trainer_type, name, versions_count)
Deprecation.warn_method("pbPhoneRegisterBattle", "v22", "several scripts and event commands; see def pbPhoneRegisterBattle") Deprecation.warn_method("pbPhoneRegisterBattle", "v22", "several scripts and event commands; see def pbPhoneRegisterBattle")

95
Data/Scripts/013_Items/008_PokemonBag.rb
View File

@@ -328,98 +328,3 @@ module ItemStorageHelper
return ret return ret
end end
end end
#===============================================================================
# Deprecated methods
#===============================================================================
class PokemonBag
# @deprecated This method is slated to be removed in v21.
def pbQuantity(item)
Deprecation.warn_method("pbQuantity", "v21", "$bag.quantity(item)")
return quantity(item)
end
# @deprecated This method is slated to be removed in v21.
def pbHasItem?(item)
Deprecation.warn_method("pbHasItem?", "v21", "$bag.has?(item)")
return has?(item)
end
# @deprecated This method is slated to be removed in v21.
def pbCanStore?(item, quantity = 1)
Deprecation.warn_method("pbCanStore?", "v21", "$bag.can_add?(item, quantity)")
return can_add?(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbStoreItem(item, quantity = 1)
Deprecation.warn_method("pbStoreItem", "v21", "$bag.add(item, quantity)")
return add(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbStoreAllOrNone(item, quantity = 1)
Deprecation.warn_method("pbStoreAllOrNone", "v21", "$bag.add_all(item, quantity)")
return add_all(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbChangeItem(old_item, new_item)
Deprecation.warn_method("pbChangeItem", "v21", "$bag.replace_item(old_item, new_item)")
return replace_item(old_item, new_item)
end
# @deprecated This method is slated to be removed in v21.
def pbDeleteItem(item, quantity = 1)
Deprecation.warn_method("pbDeleteItem", "v21", "$bag.remove(item, quantity)")
return remove(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbIsRegistered?(item)
Deprecation.warn_method("pbIsRegistered?", "v21", "$bag.registered?(item)")
return registered?(item)
end
# @deprecated This method is slated to be removed in v21.
def pbRegisterItem(item)
Deprecation.warn_method("pbRegisterItem", "v21", "$bag.register(item)")
register(item)
end
# @deprecated This method is slated to be removed in v21.
def pbUnregisterItem(item)
Deprecation.warn_method("pbUnregisterItem", "v21", "$bag.unregister(item)")
unregister(item)
end
end
# @deprecated This method is slated to be removed in v21.
def pbQuantity(item)
Deprecation.warn_method("pbQuantity", "v21", "$bag.quantity(item)")
return $bag.quantity(item)
end
# @deprecated This method is slated to be removed in v21.
def pbHasItem?(item)
Deprecation.warn_method("pbHasItem?", "v21", "$bag.has?(item)")
return $bag.has?(item)
end
# @deprecated This method is slated to be removed in v21.
def pbCanStore?(item, quantity = 1)
Deprecation.warn_method("pbCanStore?", "v21", "$bag.can_add?(item, quantity)")
return $bag.can_add?(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbStoreItem(item, quantity = 1)
Deprecation.warn_method("pbStoreItem", "v21", "$bag.add(item, quantity)")
return $bag.add(item, quantity)
end
# @deprecated This method is slated to be removed in v21.
def pbStoreAllOrNone(item, quantity = 1)
Deprecation.warn_method("pbStoreAllOrNone", "v21", "$bag.add_all(item, quantity)")
return $bag.add_all(item, quantity)
end

8
Data/Scripts/014_Pokemon/001_Pokemon.rb
View File

@@ -314,15 +314,15 @@ class Pokemon
return species_data.types.clone return species_data.types.clone
end end
# @deprecated This method is slated to be removed in v21. # @deprecated This method is slated to be removed in v22.
def type1 def type1
Deprecation.warn_method("type1", "v21", "pkmn.types") Deprecation.warn_method("type1", "v22", "pkmn.types")
return types[0] return types[0]
end end
# @deprecated This method is slated to be removed in v21. # @deprecated This method is slated to be removed in v22.
def type2 def type2
Deprecation.warn_method("type2", "v21", "pkmn.types") Deprecation.warn_method("type2", "v22", "pkmn.types")
return types[1] || types[0] return types[1] || types[0]
end end

8
Data/Scripts/014_Pokemon/004_Pokemon_Move.rb
View File

@@ -48,7 +48,7 @@ class Pokemon
alias totalpp total_pp alias totalpp total_pp
def function_code; return GameData::Move.get(@id).function_code; end def function_code; return GameData::Move.get(@id).function_code; end
def base_damage; return GameData::Move.get(@id).base_damage; end def power; return GameData::Move.get(@id).power; end
def type; return GameData::Move.get(@id).type; end def type; return GameData::Move.get(@id).type; end
def category; return GameData::Move.get(@id).category; end def category; return GameData::Move.get(@id).category; end
def accuracy; return GameData::Move.get(@id).accuracy; end def accuracy; return GameData::Move.get(@id).accuracy; end
@@ -60,6 +60,12 @@ class Pokemon
def description; return GameData::Move.get(@id).description; end def description; return GameData::Move.get(@id).description; end
def hidden_move?; return GameData::Move.get(@id).hidden_move?; end def hidden_move?; return GameData::Move.get(@id).hidden_move?; end
# @deprecated This method is slated to be removed in v22.
def base_damage
Deprecation.warn_method("base_damage", "v22", "power")
return @power
end
def display_type(pkmn); return GameData::Move.get(@id).display_type(pkmn, self); end def display_type(pkmn); return GameData::Move.get(@id).display_type(pkmn, self); end
def display_category(pkmn); return GameData::Move.get(@id).display_category(pkmn, self); end def display_category(pkmn); return GameData::Move.get(@id).display_category(pkmn, self); end
def display_damage(pkmn); return GameData::Move.get(@id).display_damage(pkmn, self); end def display_damage(pkmn); return GameData::Move.get(@id).display_damage(pkmn, self); end

4
Data/Scripts/015_Trainers and player/002_Trainer_LoadAndNew.rb
View File

@@ -37,7 +37,7 @@ def pbNewTrainer(tr_type, tr_name, tr_version, save_changes = true)
if save_changes if save_changes
trainer_hash = { trainer_hash = {
:trainer_type => tr_type, :trainer_type => tr_type,
:name => tr_name, :real_name => tr_name,
:version => tr_version, :version => tr_version,
:pokemon => [] :pokemon => []
} }
@@ -50,7 +50,7 @@ def pbNewTrainer(tr_type, tr_name, tr_version, save_changes = true)
) )
end end
# Add trainer's data to records # Add trainer's data to records
trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:name], trainer_hash[:version]] trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:real_name], trainer_hash[:version]]
GameData::Trainer.register(trainer_hash) GameData::Trainer.register(trainer_hash)
GameData::Trainer.save GameData::Trainer.save
pbConvertTrainerData pbConvertTrainerData

4
Data/Scripts/016_UI/022_UI_MoveRelearner.rb
View File

@@ -84,12 +84,12 @@ class MoveRelearner_Scene
0, 78 + ((@sprites["commands"].index - @sprites["commands"].top_item) * 64), 0, 78 + ((@sprites["commands"].index - @sprites["commands"].top_item) * 64),
0, 0, 258, 72]) 0, 0, 258, 72])
selMoveData = GameData::Move.get(@moves[@sprites["commands"].index]) selMoveData = GameData::Move.get(@moves[@sprites["commands"].index])
basedamage = selMoveData.display_damage(@pokemon) power = selMoveData.display_damage(@pokemon)
category = selMoveData.display_category(@pokemon) category = selMoveData.display_category(@pokemon)
accuracy = selMoveData.display_accuracy(@pokemon) accuracy = selMoveData.display_accuracy(@pokemon)
textpos.push([_INTL("CATEGORY"), 272, 120, 0, Color.new(248, 248, 248), Color.black]) textpos.push([_INTL("CATEGORY"), 272, 120, 0, Color.new(248, 248, 248), Color.black])
textpos.push([_INTL("POWER"), 272, 152, 0, Color.new(248, 248, 248), Color.black]) textpos.push([_INTL("POWER"), 272, 152, 0, Color.new(248, 248, 248), Color.black])
textpos.push([basedamage <= 1 ? basedamage == 1 ? "???" : "---" : sprintf("%d", basedamage), textpos.push([power <= 1 ? power == 1 ? "???" : "---" : sprintf("%d", power),
468, 152, 2, Color.new(64, 64, 64), Color.new(176, 176, 176)]) 468, 152, 2, Color.new(64, 64, 64), Color.new(176, 176, 176)])
textpos.push([_INTL("ACCURACY"), 272, 184, 0, Color.new(248, 248, 248), Color.black]) textpos.push([_INTL("ACCURACY"), 272, 184, 0, Color.new(248, 248, 248), Color.black])
textpos.push([accuracy == 0 ? "---" : "#{accuracy}%", textpos.push([accuracy == 0 ? "---" : "#{accuracy}%",

36
Data/Scripts/018_Alternate battle modes/003_Battle Frontier generator/002_ChallengeGenerator_Pokemon.rb
View File

@@ -76,12 +76,12 @@ def pbGetLegalMoves2(species, maxlevel)
# If we have a move that always hits, remove all other moves with no # If we have a move that always hits, remove all other moves with no
# effect of the same type and <= base power # effect of the same type and <= base power
if md.accuracy == 0 && move2[1].function_code == "None" && if md.accuracy == 0 && move2[1].function_code == "None" &&
md.type == move2[1].type && md.base_damage >= move2[1].base_damage md.type == move2[1].type && md.power >= move2[1].power
deleteAll.call(moves, move2[0]) deleteAll.call(moves, move2[0])
# If we have two status moves that have the same function code, delete the # If we have two status moves that have the same function code, delete the
# one with lower accuracy (Supersonic vs. Confuse Ray, etc.) # one with lower accuracy (Supersonic vs. Confuse Ray, etc.)
elsif md.function_code == move2[1].function_code && md.base_damage == 0 && elsif md.function_code == move2[1].function_code && md.power == 0 &&
move2[1].base_damage == 0 && md.accuracy > move2[1].accuracy move2[1].power == 0 && md.accuracy > move2[1].accuracy
deleteAll.call(moves, move2[0]) deleteAll.call(moves, move2[0])
# Delete poison-causing moves if we have a move that causes toxic # Delete poison-causing moves if we have a move that causes toxic
elsif md.function_code == "BadPoisonTarget" && move2[1].function_code == "PoisonTarget" elsif md.function_code == "BadPoisonTarget" && move2[1].function_code == "PoisonTarget"
@@ -90,11 +90,11 @@ def pbGetLegalMoves2(species, maxlevel)
# them is damaging and has 10/15/the same PP as the other move and EITHER # them is damaging and has 10/15/the same PP as the other move and EITHER
# does more damage than the other move OR does the same damage but is more # does more damage than the other move OR does the same damage but is more
# accurate, delete the other move (Surf, Flamethrower, Thunderbolt, etc.) # accurate, delete the other move (Surf, Flamethrower, Thunderbolt, etc.)
elsif md.function_code == move2[1].function_code && md.base_damage != 0 && elsif md.function_code == move2[1].function_code && md.power != 0 &&
md.type == move2[1].type && md.type == move2[1].type &&
(md.total_pp == 15 || md.total_pp == 10 || md.total_pp == move2[1].total_pp) && (md.total_pp == 15 || md.total_pp == 10 || md.total_pp == move2[1].total_pp) &&
(md.base_damage > move2[1].base_damage || (md.power > move2[1].power ||
(md.base_damage == move2[1].base_damage && md.accuracy > move2[1].accuracy)) (md.power == move2[1].power && md.accuracy > move2[1].accuracy))
deleteAll.call(moves, move2[0]) deleteAll.call(moves, move2[0])
end end
end end
@@ -107,15 +107,15 @@ def addMove(moves, move, base)
return if moves.include?(data.id) return if moves.include?(data.id)
return if [:BUBBLE, :BUBBLEBEAM].include?(data.id) # Never add these moves return if [:BUBBLE, :BUBBLEBEAM].include?(data.id) # Never add these moves
count = base + 1 # Number of times to add move to moves count = base + 1 # Number of times to add move to moves
count = base if data.function_code == "None" && data.base_damage <= 40 count = base if data.function_code == "None" && data.power <= 40
if data.base_damage <= 30 || [:GROWL, :TAILWHIP, :LEER].include?(data.id) if data.power <= 30 || [:GROWL, :TAILWHIP, :LEER].include?(data.id)
count = base count = base
end end
if data.base_damage >= 60 || if data.power >= 60 ||
[:REFLECT, :LIGHTSCREEN, :SAFEGUARD, :SUBSTITUTE, :FAKEOUT].include?(data.id) [:REFLECT, :LIGHTSCREEN, :SAFEGUARD, :SUBSTITUTE, :FAKEOUT].include?(data.id)
count = base + 2 count = base + 2
end end
count = base + 3 if data.base_damage >= 80 && data.type == :NORMAL count = base + 3 if data.power >= 80 && data.type == :NORMAL
if [:PROTECT, :DETECT, :TOXIC, :AERIALACE, :WILLOWISP, :SPORE, :THUNDERWAVE, if [:PROTECT, :DETECT, :TOXIC, :AERIALACE, :WILLOWISP, :SPORE, :THUNDERWAVE,
:HYPNOSIS, :CONFUSERAY, :ENDURE, :SWORDSDANCE].include?(data.id) :HYPNOSIS, :CONFUSERAY, :ENDURE, :SWORDSDANCE].include?(data.id)
count = base + 3 count = base + 3
@@ -127,11 +127,11 @@ end
# with a higher base damage than it. # with a higher base damage than it.
def hasMorePowerfulMove(moves, thismove) def hasMorePowerfulMove(moves, thismove)
thisdata = GameData::Move.get(thismove) thisdata = GameData::Move.get(thismove)
return false if thisdata.base_damage == 0 return false if thisdata.power == 0
moves.each do |move| moves.each do |move|
next if !move next if !move
moveData = GameData::Move.get(move) moveData = GameData::Move.get(move)
if moveData.type == thisdata.type && moveData.base_damage > thisdata.base_damage if moveData.type == thisdata.type && moveData.power > thisdata.power
return true return true
end end
end end
@@ -297,14 +297,14 @@ def pbRandomPokemonFromRule(rules, trainer)
!((sketch || !moves.include?(rest)) && rand(100) < 20) !((sketch || !moves.include?(rest)) && rand(100) < 20)
next next
end end
totalbasedamage = 0 total_power = 0
hasPhysical = false hasPhysical = false
hasSpecial = false hasSpecial = false
hasNormal = false hasNormal = false
newmoves.each do |move| newmoves.each do |move|
d = GameData::Move.get(move) d = GameData::Move.get(move)
next if d.base_damage == 0 next if d.power == 0
totalbasedamage += d.base_damage total_power += d.power
hasNormal = true if d.type == :NORMAL hasNormal = true if d.type == :NORMAL
hasPhysical = true if d.category == 0 hasPhysical = true if d.category == 0
hasSpecial = true if d.category == 1 hasSpecial = true if d.category == 1
@@ -318,9 +318,9 @@ def pbRandomPokemonFromRule(rules, trainer)
next next
end end
r = rand(10) r = rand(10)
next if r > 6 && totalbasedamage > 180 next if r > 6 && total_power > 180
next if r > 8 && totalbasedamage > 140 next if r > 8 && total_power > 140
next if totalbasedamage == 0 && rand(100) < 95 next if total_power == 0 && rand(100) < 95
############ ############
# Moves accepted # Moves accepted
if hasPhysical && !hasSpecial if hasPhysical && !hasSpecial

2
Data/Scripts/018_Alternate battle modes/003_Battle Frontier generator/004_ChallengeGenerator_BattleSim.rb
View File

@@ -309,7 +309,7 @@ end
#=============================================================================== #===============================================================================
def pbDecideWinnerEffectiveness(move, otype1, otype2, ability, scores) def pbDecideWinnerEffectiveness(move, otype1, otype2, ability, scores)
data = GameData::Move.get(move) data = GameData::Move.get(move)
return 0 if data.base_damage == 0 return 0 if data.power == 0
atype = data.type atype = data.type
typemod = 1.0 typemod = 1.0
if ability != :LEVITATE || data.type != :GROUND if ability != :LEVITATE || data.type != :GROUND

14
Data/Scripts/020_Debug/001_Editor screens/001_EditorScreens.rb
View File

@@ -525,7 +525,7 @@ def pbTrainerBattleEditor
else else
trainer_hash = { trainer_hash = {
:trainer_type => data[0], :trainer_type => data[0],
:name => data[1], :real_name => data[1],
:version => data[2], :version => data[2],
:lose_text => data[3], :lose_text => data[3],
:pokemon => party, :pokemon => party,
@@ -533,7 +533,7 @@ def pbTrainerBattleEditor
:pbs_file_suffix => tr_data.pbs_file_suffix :pbs_file_suffix => tr_data.pbs_file_suffix
} }
# Add trainer type's data to records # Add trainer type's data to records
trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:name], trainer_hash[:version]] trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:real_name], trainer_hash[:version]]
GameData::Trainer.register(trainer_hash) GameData::Trainer.register(trainer_hash)
if data[0] != old_type || data[1] != old_name || data[2] != old_version if data[0] != old_type || data[1] != old_name || data[2] != old_version
GameData::Trainer::DATA.delete([old_type, old_name, old_version]) GameData::Trainer::DATA.delete([old_type, old_name, old_version])
@@ -568,7 +568,7 @@ def pbTrainerBattleEditor
if t if t
trainer_hash = { trainer_hash = {
:trainer_type => tr_type, :trainer_type => tr_type,
:name => tr_name, :real_name => tr_name,
:version => tr_version, :version => tr_version,
:pokemon => [] :pokemon => []
} }
@@ -581,7 +581,7 @@ def pbTrainerBattleEditor
) )
end end
# Add trainer's data to records # Add trainer's data to records
trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:name], trainer_hash[:version]] trainer_hash[:id] = [trainer_hash[:trainer_type], trainer_hash[:real_name], trainer_hash[:version]]
GameData::Trainer.register(trainer_hash) GameData::Trainer.register(trainer_hash)
pbMessage(_INTL("The Trainer battle was added.")) pbMessage(_INTL("The Trainer battle was added."))
modified = true modified = true
@@ -607,7 +607,7 @@ module TrainerPokemonProperty
oldsetting = [ oldsetting = [
initsetting[:species], initsetting[:species],
initsetting[:level], initsetting[:level],
initsetting[:name], initsetting[:real_name],
initsetting[:form], initsetting[:form],
initsetting[:gender], initsetting[:gender],
initsetting[:shininess], initsetting[:shininess],
@@ -629,7 +629,7 @@ module TrainerPokemonProperty
pkmn_properties = [ pkmn_properties = [
[_INTL("Species"), SpeciesProperty, _INTL("Species of the Pokémon.")], [_INTL("Species"), SpeciesProperty, _INTL("Species of the Pokémon.")],
[_INTL("Level"), NonzeroLimitProperty.new(max_level), _INTL("Level of the Pokémon (1-{1}).", max_level)], [_INTL("Level"), NonzeroLimitProperty.new(max_level), _INTL("Level of the Pokémon (1-{1}).", max_level)],
[_INTL("Name"), StringProperty, _INTL("Name of the Pokémon.")], [_INTL("Name"), StringProperty, _INTL("Nickname of the Pokémon.")],
[_INTL("Form"), LimitProperty2.new(999), _INTL("Form of the Pokémon.")], [_INTL("Form"), LimitProperty2.new(999), _INTL("Form of the Pokémon.")],
[_INTL("Gender"), GenderProperty, _INTL("Gender of the Pokémon.")], [_INTL("Gender"), GenderProperty, _INTL("Gender of the Pokémon.")],
[_INTL("Shiny"), BooleanProperty2, _INTL("If set to true, the Pokémon is a different-colored Pokémon.")], [_INTL("Shiny"), BooleanProperty2, _INTL("If set to true, the Pokémon is a different-colored Pokémon.")],
@@ -655,7 +655,7 @@ module TrainerPokemonProperty
ret = { ret = {
:species => oldsetting[0], :species => oldsetting[0],
:level => oldsetting[1], :level => oldsetting[1],
:name => oldsetting[2], :real_name => oldsetting[2],
:form => oldsetting[3], :form => oldsetting[3],
:gender => oldsetting[4], :gender => oldsetting[4],
:shininess => oldsetting[5], :shininess => oldsetting[5],

1
Data/Scripts/020_Debug/001_Editor screens/004_EditorScreens_SpritePositioning.rb
View File

@@ -213,6 +213,7 @@ class SpritePositioner
break break
elsif Input.trigger?(Input::USE) elsif Input.trigger?(Input::USE)
pbPlayDecisionSE pbPlayDecisionSE
@metricsChanged = true if metrics_data.shadow_size != oldval
break break
end end
end end

5
Data/Scripts/020_Debug/002_Animation editor/005_AnimEditor_Functions.rb
View File

@@ -534,7 +534,7 @@ def pbSelectSE(canvas, audio)
cmdwin.update cmdwin.update
maxsizewindow.update maxsizewindow.update
if maxsizewindow.changed?(3) && animfiles.length > 0 # Play Sound if maxsizewindow.changed?(3) && animfiles.length > 0 # Play Sound
fname = (cmdwin.index == 0) ? "Cries/001Cry" : "Anim/" + filename fname = (cmdwin.index == 0) ? "Cries/000" : "Anim/" + filename
pbSEPlay(RPG::AudioFile.new(fname, maxsizewindow.value(1), maxsizewindow.value(2))) pbSEPlay(RPG::AudioFile.new(fname, maxsizewindow.value(1), maxsizewindow.value(2)))
end end
pbSEStop if maxsizewindow.changed?(4) && animfiles.length > 0 # Stop Sound pbSEStop if maxsizewindow.changed?(4) && animfiles.length > 0 # Stop Sound
@@ -572,7 +572,6 @@ def pbSelectBG(canvas, timing)
# animfiles.concat(Dir.glob("*.jpeg")) # animfiles.concat(Dir.glob("*.jpeg"))
# animfiles.concat(Dir.glob("*.bmp")) # animfiles.concat(Dir.glob("*.bmp"))
end end
animfiles.map! { |f| File.basename(f, ".*") }
animfiles.uniq! animfiles.uniq!
animfiles.sort! { |a, b| a.downcase <=> b.downcase } animfiles.sort! { |a, b| a.downcase <=> b.downcase }
cmdwin = pbListWindow(animfiles, 320) cmdwin = pbListWindow(animfiles, 320)
@@ -598,7 +597,7 @@ def pbSelectBG(canvas, timing)
cmdwin.update cmdwin.update
maxsizewindow.update maxsizewindow.update
if maxsizewindow.changed?(8) # OK if maxsizewindow.changed?(8) # OK
timing.name = filename timing.name = File.basename(filename, ".*")
timing.bgX = maxsizewindow.value(1) timing.bgX = maxsizewindow.value(1)
timing.bgY = maxsizewindow.value(2) timing.bgY = maxsizewindow.value(2)
timing.opacity = maxsizewindow.value(3) timing.opacity = maxsizewindow.value(3)

22
Data/Scripts/021_Compiler/001_Compiler.rb
View File

@@ -862,9 +862,9 @@ module Compiler
# Get all data files and PBS files to be checked for their last modified times # Get all data files and PBS files to be checked for their last modified times
data_files = GameData.get_all_data_filenames data_files = GameData.get_all_data_filenames
data_files += [ # Extra .dat files for data that isn't a GameData class data_files += [ # Extra .dat files for data that isn't a GameData class
"map_connections.dat", ["map_connections.dat", true],
"regional_dexes.dat", ["regional_dexes.dat", true],
"trainer_lists.dat" ["trainer_lists.dat", true]
] ]
text_files = get_all_pbs_files_to_compile text_files = get_all_pbs_files_to_compile
latestDataTime = 0 latestDataTime = 0
@@ -880,16 +880,16 @@ module Compiler
mustCompile = true mustCompile = true
end end
# Check data files for their latest modify time # Check data files for their latest modify time
data_files.each do |filename| data_files.each do |filename| # filename = [string, boolean (whether mandatory)]
if safeExists?("Data/" + filename) if safeExists?("Data/" + filename[0])
begin begin
File.open("Data/#{filename}") do |file| File.open("Data/#{filename[0]}") do |file|
latestDataTime = [latestDataTime, file.mtime.to_i].max latestDataTime = [latestDataTime, file.mtime.to_i].max
end end
rescue SystemCallError rescue SystemCallError
mustCompile = true mustCompile = true
end end
elsif filename != "shadow_pokemon.dat" elsif filename[1]
mustCompile = true mustCompile = true
break break
end end
@@ -911,9 +911,9 @@ module Compiler
mustCompile = true if Input.press?(Input::CTRL) mustCompile = true if Input.press?(Input::CTRL)
# Delete old data files in preparation for recompiling # Delete old data files in preparation for recompiling
if mustCompile if mustCompile
data_files.length.times do |i| data_files.each do |filename|
begin begin
File.delete("Data/#{data_files[i]}") if safeExists?("Data/#{data_files[i]}") File.delete("Data/#{filename[0]}") if safeExists?("Data/#{filename[0]}")
rescue SystemCallError rescue SystemCallError
end end
end end
@@ -924,9 +924,9 @@ module Compiler
e = $! e = $!
raise e if e.class.to_s == "Reset" || e.is_a?(Reset) || e.is_a?(SystemExit) raise e if e.class.to_s == "Reset" || e.is_a?(Reset) || e.is_a?(SystemExit)
pbPrintException(e) pbPrintException(e)
data_files.length.times do |i| data_files.each do |filename|
begin begin
File.delete("Data/#{data_files[i]}") File.delete("Data/#{filename[0]}") if safeExists?("Data/#{filename[0]}")
rescue SystemCallError rescue SystemCallError
end end
end end

21
Data/Scripts/021_Compiler/002_Compiler_CompilePBS.rb
View File

@@ -2,6 +2,9 @@ module Compiler
module_function module_function
def compile_PBS_file_generic(game_data, *paths) def compile_PBS_file_generic(game_data, *paths)
if game_data.const_defined?(:OPTIONAL) && game_data::OPTIONAL
return if paths.none? { |p| safeExists?(p) }
end
game_data::DATA.clear game_data::DATA.clear
schema = game_data.schema schema = game_data.schema
# Read from PBS file(s) # Read from PBS file(s)
@@ -212,12 +215,12 @@ module Compiler
end end
def validate_compiled_move(hash) def validate_compiled_move(hash)
if (hash[:category] || 2) == 2 && (hash[:base_damage] || 0) != 0 if (hash[:category] || 2) == 2 && (hash[:power] || 0) != 0
raise _INTL("Move {1} is defined as a Status move with a non-zero base damage.\r\n{2}", raise _INTL("Move {1} is defined as a Status move with a non-zero base damage.\r\n{2}",
hash[:name], FileLineData.linereport) hash[:real_name], FileLineData.linereport)
elsif (hash[:category] || 2) != 2 && (hash[:base_damage] || 0) == 0 elsif (hash[:category] || 2) != 2 && (hash[:power] || 0) == 0
print _INTL("Warning: Move {1} is defined as Physical or Special but has a base damage of 0. Changing it to a Status move.\r\n{2}", print _INTL("Warning: Move {1} is defined as Physical or Special but has a base damage of 0. Changing it to a Status move.\r\n{2}",
hash[:name], FileLineData.linereport) hash[:real_name], FileLineData.linereport)
hash[:category] = 2 hash[:category] = 2
end end
end end
@@ -542,7 +545,6 @@ module Compiler
# Compile Shadow Pokémon data # Compile Shadow Pokémon data
#============================================================================= #=============================================================================
def compile_shadow_pokemon(*paths) def compile_shadow_pokemon(*paths)
return if !safeExists?("PBS/shadow_pokemon.txt")
compile_PBS_file_generic(GameData::ShadowPokemon, *paths) do |final_validate, hash| compile_PBS_file_generic(GameData::ShadowPokemon, *paths) do |final_validate, hash|
(final_validate) ? validate_all_compiled_shadow_pokemon : validate_compiled_shadow_pokemon(hash) (final_validate) ? validate_all_compiled_shadow_pokemon : validate_compiled_shadow_pokemon(hash)
end end
@@ -847,9 +849,9 @@ module Compiler
pkmn[:level], max_level, FileLineData.linereport) pkmn[:level], max_level, FileLineData.linereport)
end end
# Ensure valid name length # Ensure valid name length
if pkmn[:name] && pkmn[:name].length > Pokemon::MAX_NAME_SIZE if pkmn[:real_name] && pkmn[:real_name].length > Pokemon::MAX_NAME_SIZE
raise _INTL("Invalid Pokémon nickname: {1} (must be 1-{2} characters).\r\n{3}", raise _INTL("Invalid Pokémon nickname: {1} (must be 1-{2} characters).\r\n{3}",
pkmn[:name], Pokemon::MAX_NAME_SIZE, FileLineData.linereport) pkmn[:real_name], Pokemon::MAX_NAME_SIZE, FileLineData.linereport)
end end
# Ensure no duplicate moves # Ensure no duplicate moves
pkmn[:moves].uniq! if pkmn[:moves] pkmn[:moves].uniq! if pkmn[:moves]
@@ -904,12 +906,17 @@ module Compiler
# Get trainer names and lose texts for translating # Get trainer names and lose texts for translating
trainer_names = [] trainer_names = []
lose_texts = [] lose_texts = []
pokemon_nicknames = []
GameData::Trainer.each do |trainer| GameData::Trainer.each do |trainer|
trainer_names.push(trainer.real_name) trainer_names.push(trainer.real_name)
lose_texts.push(trainer.real_lose_text) lose_texts.push(trainer.real_lose_text)
trainer.pokemon.each do |pkmn|
pokemon_nicknames.push(pkmn[:real_name]) if !nil_or_empty?(pkmn[:real_name])
end
end end
MessageTypes.setMessagesAsHash(MessageTypes::TRAINER_NAMES, trainer_names) MessageTypes.setMessagesAsHash(MessageTypes::TRAINER_NAMES, trainer_names)
MessageTypes.setMessagesAsHash(MessageTypes::TRAINER_SPEECHES_LOSE, lose_texts) MessageTypes.setMessagesAsHash(MessageTypes::TRAINER_SPEECHES_LOSE, lose_texts)
MessageTypes.setMessagesAsHash(MessageTypes::POKEMON_NICKNAMES, pokemon_nicknames)
end end
#============================================================================= #=============================================================================