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
Files
47b164f0ab40945e3ba3f23f91ddcd494f0d3445
infinitefusion-e18/Data/Scripts/012_Battle/007_BattleHandlers_Abilities.rb
Maruno17 611d0a74eb Added class GameData::BattleWeather
2021-02-21 19:04:36 +00:00

2424 lines
82 KiB
Ruby
Raw Blame History

#===============================================================================
# SpeedCalcAbility handlers
#===============================================================================
BattleHandlers::SpeedCalcAbility.add(:CHLOROPHYLL,
proc { |ability,battler,mult|
next mult * 2 if [:Sun, :HarshSun].include?(battler.battle.pbWeather)
}
)
BattleHandlers::SpeedCalcAbility.add(:QUICKFEET,
proc { |ability,battler,mult|
next mult*1.5 if battler.pbHasAnyStatus?
}
)
BattleHandlers::SpeedCalcAbility.add(:SANDRUSH,
proc { |ability,battler,mult|
next mult * 2 if [:Sandstorm].include?(battler.battle.pbWeather)
}
)
BattleHandlers::SpeedCalcAbility.add(:SLOWSTART,
proc { |ability,battler,mult|
next mult/2 if battler.effects[PBEffects::SlowStart]>0
}
)
BattleHandlers::SpeedCalcAbility.add(:SLUSHRUSH,
proc { |ability,battler,mult|
next mult * 2 if [:Hail].include?(battler.battle.pbWeather)
}
)
BattleHandlers::SpeedCalcAbility.add(:SURGESURFER,
proc { |ability,battler,mult|
next mult*2 if battler.battle.field.terrain == :Electric
}
)
BattleHandlers::SpeedCalcAbility.add(:SWIFTSWIM,
proc { |ability,battler,mult|
next mult * 2 if [:Rain, :HeavyRain].include?(battler.battle.pbWeather)
}
)
BattleHandlers::SpeedCalcAbility.add(:UNBURDEN,
proc { |ability,battler,mult|
next mult*2 if battler.effects[PBEffects::Unburden] && !battler.item
}
)
#===============================================================================
# WeightCalcAbility handlers
#===============================================================================
BattleHandlers::WeightCalcAbility.add(:HEAVYMETAL,
proc { |ability,battler,w|
next w*2
}
)
BattleHandlers::WeightCalcAbility.add(:LIGHTMETAL,
proc { |ability,battler,w|
next [w/2,1].max
}
)
#===============================================================================
# AbilityOnHPDroppedBelowHalf handlers
#===============================================================================
BattleHandlers::AbilityOnHPDroppedBelowHalf.add(:EMERGENCYEXIT,
proc { |ability,battler,battle|
next false if battler.effects[PBEffects::SkyDrop]>=0 || battler.inTwoTurnAttack?("0CE") # Sky Drop
# In wild battles
if battle.wildBattle?
next false if battler.opposes? && battle.pbSideBattlerCount(battler.index)>1
next false if !battle.pbCanRun?(battler.index)
battle.pbShowAbilitySplash(battler,true)
battle.pbHideAbilitySplash(battler)
pbSEPlay("Battle flee")
battle.pbDisplay(_INTL("{1} fled from battle!",battler.pbThis))
battle.decision = 3 # Escaped
next true
end
# In trainer battles
next false if battle.pbAllFainted?(battler.idxOpposingSide)
next false if !battle.pbCanSwitch?(battler.index) # Battler can't switch out
next false if !battle.pbCanChooseNonActive?(battler.index) # No Pokémon can switch in
battle.pbShowAbilitySplash(battler,true)
battle.pbHideAbilitySplash(battler)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s {2} activated!",battler.pbThis,battler.abilityName))
end
battle.pbDisplay(_INTL("{1} went back to {2}!",
battler.pbThis,battle.pbGetOwnerName(battler.index)))
if battle.endOfRound # Just switch out
battle.scene.pbRecall(battler.index) if !battler.fainted?
battler.pbAbilitiesOnSwitchOut # Inc. primordial weather check
next true
end
newPkmn = battle.pbGetReplacementPokemonIndex(battler.index) # Owner chooses
next false if newPkmn<0 # Shouldn't ever do this
battle.pbRecallAndReplace(battler.index,newPkmn)
battle.pbClearChoice(battler.index) # Replacement Pokémon does nothing this round
next true
}
)
BattleHandlers::AbilityOnHPDroppedBelowHalf.copy(:EMERGENCYEXIT,:WIMPOUT)
#===============================================================================
# StatusCheckAbilityNonIgnorable handlers
#===============================================================================
BattleHandlers::StatusCheckAbilityNonIgnorable.add(:COMATOSE,
proc { |ability,battler,status|
next false if !battler.isSpecies?(:KOMALA)
next true if status.nil? || status == :SLEEP
}
)
#===============================================================================
# StatusImmunityAbility handlers
#===============================================================================
BattleHandlers::StatusImmunityAbility.add(:FLOWERVEIL,
proc { |ability,battler,status|
next true if battler.pbHasType?(:GRASS)
}
)
BattleHandlers::StatusImmunityAbility.add(:IMMUNITY,
proc { |ability,battler,status|
next true if status == :POISON
}
)
BattleHandlers::StatusImmunityAbility.add(:INSOMNIA,
proc { |ability,battler,status|
next true if status == :SLEEP
}
)
BattleHandlers::StatusImmunityAbility.copy(:INSOMNIA,:SWEETVEIL,:VITALSPIRIT)
BattleHandlers::StatusImmunityAbility.add(:LEAFGUARD,
proc { |ability,battler,status|
next true if [:Sun, :HarshSun].include?(battler.battle.pbWeather)
}
)
BattleHandlers::StatusImmunityAbility.add(:LIMBER,
proc { |ability,battler,status|
next true if status == :PARALYSIS
}
)
BattleHandlers::StatusImmunityAbility.add(:MAGMAARMOR,
proc { |ability,battler,status|
next true if status == :FROZEN
}
)
BattleHandlers::StatusImmunityAbility.add(:WATERVEIL,
proc { |ability,battler,status|
next true if status == :BURN
}
)
BattleHandlers::StatusImmunityAbility.copy(:WATERVEIL,:WATERBUBBLE)
#===============================================================================
# StatusImmunityAbilityNonIgnorable handlers
#===============================================================================
BattleHandlers::StatusImmunityAbilityNonIgnorable.add(:COMATOSE,
proc { |ability,battler,status|
next true if battler.isSpecies?(:KOMALA)
}
)
BattleHandlers::StatusImmunityAbilityNonIgnorable.add(:SHIELDSDOWN,
proc { |ability,battler,status|
next true if battler.isSpecies?(:MINIOR) && battler.form<7
}
)
#===============================================================================
# StatusImmunityAllyAbility handlers
#===============================================================================
BattleHandlers::StatusImmunityAllyAbility.add(:FLOWERVEIL,
proc { |ability,battler,status|
next true if battler.pbHasType?(:GRASS)
}
)
BattleHandlers::StatusImmunityAbility.add(:SWEETVEIL,
proc { |ability,battler,status|
next true if status == :SLEEP
}
)
#===============================================================================
# AbilityOnStatusInflicted handlers
#===============================================================================
BattleHandlers::AbilityOnStatusInflicted.add(:SYNCHRONIZE,
proc { |ability,battler,user,status|
next if !user || user.index==battler.index
case status
when :POISON
if user.pbCanPoisonSynchronize?(battler)
battler.battle.pbShowAbilitySplash(battler)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} poisoned {3}!",battler.pbThis,battler.abilityName,user.pbThis(true))
end
user.pbPoison(nil,msg,(battler.statusCount>0))
battler.battle.pbHideAbilitySplash(battler)
end
when :BURN
if user.pbCanBurnSynchronize?(battler)
battler.battle.pbShowAbilitySplash(battler)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} burned {3}!",battler.pbThis,battler.abilityName,user.pbThis(true))
end
user.pbBurn(nil,msg)
battler.battle.pbHideAbilitySplash(battler)
end
when :PARALYSIS
if user.pbCanParalyzeSynchronize?(battler)
battler.battle.pbShowAbilitySplash(battler)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} paralyzed {3}! It may be unable to move!",
battler.pbThis,battler.abilityName,user.pbThis(true))
end
user.pbParalyze(nil,msg)
battler.battle.pbHideAbilitySplash(battler)
end
end
}
)
#===============================================================================
# StatusCureAbility handlers
#===============================================================================
BattleHandlers::StatusCureAbility.add(:IMMUNITY,
proc { |ability,battler|
next if battler.status != :POISON
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s {2} cured its poisoning!",battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.add(:INSOMNIA,
proc { |ability,battler|
next if battler.status != :SLEEP
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s {2} woke it up!",battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.copy(:INSOMNIA,:VITALSPIRIT)
BattleHandlers::StatusCureAbility.add(:LIMBER,
proc { |ability,battler|
next if battler.status != :PARALYSIS
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s {2} cured its paralysis!",battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.add(:MAGMAARMOR,
proc { |ability,battler|
next if battler.status != :FROZEN
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s {2} defrosted it!",battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.add(:OBLIVIOUS,
proc { |ability,battler|
next if battler.effects[PBEffects::Attract]<0 &&
(battler.effects[PBEffects::Taunt]==0 || Settings::MECHANICS_GENERATION <= 5)
battler.battle.pbShowAbilitySplash(battler)
if battler.effects[PBEffects::Attract]>=0
battler.pbCureAttract
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1} got over its infatuation.",battler.pbThis))
else
battler.battle.pbDisplay(_INTL("{1}'s {2} cured its infatuation status!",
battler.pbThis,battler.abilityName))
end
end
if battler.effects[PBEffects::Taunt]>0 && Settings::MECHANICS_GENERATION >= 6
battler.effects[PBEffects::Taunt] = 0
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s Taunt wore off!",battler.pbThis))
else
battler.battle.pbDisplay(_INTL("{1}'s {2} made its taunt wear off!",
battler.pbThis,battler.abilityName))
end
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.add(:OWNTEMPO,
proc { |ability,battler|
next if battler.effects[PBEffects::Confusion]==0
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureConfusion
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1} snapped out of its confusion.",battler.pbThis))
else
battler.battle.pbDisplay(_INTL("{1}'s {2} snapped it out of its confusion!",
battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.add(:WATERVEIL,
proc { |ability,battler|
next if battler.status != :BURN
battler.battle.pbShowAbilitySplash(battler)
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battler.battle.pbDisplay(_INTL("{1}'s {2} healed its burn!",battler.pbThis,battler.abilityName))
end
battler.battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::StatusCureAbility.copy(:WATERVEIL,:WATERBUBBLE)
#===============================================================================
# StatLossImmunityAbility handlers
#===============================================================================
BattleHandlers::StatLossImmunityAbility.add(:BIGPECKS,
proc { |ability,battler,stat,battle,showMessages|
next false if stat!=PBStats::DEFENSE
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s {2} cannot be lowered!",battler.pbThis,PBStats.getName(stat)))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents {3} loss!",battler.pbThis,
battler.abilityName,PBStats.getName(stat)))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
BattleHandlers::StatLossImmunityAbility.add(:CLEARBODY,
proc { |ability,battler,stat,battle,showMessages|
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s stats cannot be lowered!",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents stat loss!",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
BattleHandlers::StatLossImmunityAbility.copy(:CLEARBODY,:WHITESMOKE)
BattleHandlers::StatLossImmunityAbility.add(:FLOWERVEIL,
proc { |ability,battler,stat,battle,showMessages|
next false if !battler.pbHasType?(:GRASS)
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s stats cannot be lowered!",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents stat loss!",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
BattleHandlers::StatLossImmunityAbility.add(:HYPERCUTTER,
proc { |ability,battler,stat,battle,showMessages|
next false if stat!=PBStats::ATTACK
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s {2} cannot be lowered!",battler.pbThis,PBStats.getName(stat)))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents {3} loss!",battler.pbThis,
battler.abilityName,PBStats.getName(stat)))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
BattleHandlers::StatLossImmunityAbility.add(:KEENEYE,
proc { |ability,battler,stat,battle,showMessages|
next false if stat!=PBStats::ACCURACY
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s {2} cannot be lowered!",battler.pbThis,PBStats.getName(stat)))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents {3} loss!",battler.pbThis,
battler.abilityName,PBStats.getName(stat)))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
#===============================================================================
# StatLossImmunityAbilityNonIgnorable handlers
#===============================================================================
BattleHandlers::StatLossImmunityAbilityNonIgnorable.add(:FULLMETALBODY,
proc { |ability,battler,stat,battle,showMessages|
if showMessages
battle.pbShowAbilitySplash(battler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s stats cannot be lowered!",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents stat loss!",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
end
next true
}
)
#===============================================================================
# StatLossImmunityAllyAbility handlers
#===============================================================================
BattleHandlers::StatLossImmunityAllyAbility.add(:FLOWERVEIL,
proc { |ability,bearer,battler,stat,battle,showMessages|
next false if !battler.pbHasType?(:GRASS)
if showMessages
battle.pbShowAbilitySplash(bearer)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s stats cannot be lowered!",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} prevents {3}'s stat loss!",
bearer.pbThis,bearer.abilityName,battler.pbThis(true)))
end
battle.pbHideAbilitySplash(bearer)
end
next true
}
)
#===============================================================================
# AbilityOnStatGain handlers
#===============================================================================
# There aren't any!
#===============================================================================
# AbilityOnStatLoss handlers
#===============================================================================
BattleHandlers::AbilityOnStatLoss.add(:COMPETITIVE,
proc { |ability,battler,stat,user|
next if user && !user.opposes?(battler)
battler.pbRaiseStatStageByAbility(PBStats::SPATK,2,battler)
}
)
BattleHandlers::AbilityOnStatLoss.add(:DEFIANT,
proc { |ability,battler,stat,user|
next if user && !user.opposes?(battler)
battler.pbRaiseStatStageByAbility(PBStats::ATTACK,2,battler)
}
)
#===============================================================================
# PriorityChangeAbility handlers
#===============================================================================
BattleHandlers::PriorityChangeAbility.add(:GALEWINGS,
proc { |ability,battler,move,pri|
next pri+1 if battler.hp==battler.totalhp && move.type == :FLYING
}
)
BattleHandlers::PriorityChangeAbility.add(:PRANKSTER,
proc { |ability,battler,move,pri|
if move.statusMove?
battler.effects[PBEffects::Prankster] = true
next pri+1
end
}
)
BattleHandlers::PriorityChangeAbility.add(:TRIAGE,
proc { |ability,battler,move,pri|
next pri+3 if move.healingMove?
}
)
#===============================================================================
# PriorityBracketChangeAbility handlers
#===============================================================================
BattleHandlers::PriorityBracketChangeAbility.add(:STALL,
proc { |ability,battler,subPri,battle|
next -1 if subPri==0
}
)
#===============================================================================
# PriorityBracketUseAbility handlers
#===============================================================================
# There aren't any!
#===============================================================================
# AbilityOnFlinch handlers
#===============================================================================
BattleHandlers::AbilityOnFlinch.add(:STEADFAST,
proc { |ability,battler,battle|
battler.pbRaiseStatStageByAbility(PBStats::SPEED,1,battler)
}
)
#===============================================================================
# MoveBlockingAbility handlers
#===============================================================================
BattleHandlers::MoveBlockingAbility.add(:DAZZLING,
proc { |ability,bearer,user,targets,move,battle|
next false if battle.choices[user.index][4]<=0
next false if !bearer.opposes?(user)
ret = false
targets.each do |b|
next if !b.opposes?(user)
ret = true
end
next ret
}
)
BattleHandlers::MoveBlockingAbility.copy(:DAZZLING,:QUEENLYMAJESTY)
#===============================================================================
# MoveImmunityTargetAbility handlers
#===============================================================================
BattleHandlers::MoveImmunityTargetAbility.add(:BULLETPROOF,
proc { |ability,user,target,move,type,battle|
next false if !move.bombMove?
battle.pbShowAbilitySplash(target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("It doesn't affect {1}...",target.pbThis(true)))
else
battle.pbDisplay(_INTL("{1}'s {2} made {3} ineffective!",
target.pbThis,target.abilityName,move.name))
end
battle.pbHideAbilitySplash(target)
next true
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:FLASHFIRE,
proc { |ability,user,target,move,type,battle|
next false if user.index==target.index
next false if type != :FIRE
battle.pbShowAbilitySplash(target)
if !target.effects[PBEffects::FlashFire]
target.effects[PBEffects::FlashFire] = true
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("The power of {1}'s Fire-type moves rose!",target.pbThis(true)))
else
battle.pbDisplay(_INTL("The power of {1}'s Fire-type moves rose because of its {2}!",
target.pbThis(true),target.abilityName))
end
else
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("It doesn't affect {1}...",target.pbThis(true)))
else
battle.pbDisplay(_INTL("{1}'s {2} made {3} ineffective!",
target.pbThis,target.abilityName,move.name))
end
end
battle.pbHideAbilitySplash(target)
next true
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:LIGHTNINGROD,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityStatAbility(user,target,move,type,:ELECTRIC,PBStats::SPATK,1,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:MOTORDRIVE,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityStatAbility(user,target,move,type,:ELECTRIC,PBStats::SPEED,1,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:SAPSIPPER,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityStatAbility(user,target,move,type,:GRASS,PBStats::ATTACK,1,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:SOUNDPROOF,
proc { |ability,user,target,move,type,battle|
next false if !move.soundMove?
battle.pbShowAbilitySplash(target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("It doesn't affect {1}...",target.pbThis(true)))
else
battle.pbDisplay(_INTL("{1}'s {2} blocks {3}!",target.pbThis,target.abilityName,move.name))
end
battle.pbHideAbilitySplash(target)
next true
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:STORMDRAIN,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityStatAbility(user,target,move,type,:WATER,PBStats::SPATK,1,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:TELEPATHY,
proc { |ability,user,target,move,type,battle|
next false if move.statusMove?
next false if user.index==target.index || target.opposes?(user)
battle.pbShowAbilitySplash(target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} avoids attacks by its ally Pokémon!",target.pbThis(true)))
else
battle.pbDisplay(_INTL("{1} avoids attacks by its ally Pokémon with {2}!",
target.pbThis,target.abilityName))
end
battle.pbHideAbilitySplash(target)
next true
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:VOLTABSORB,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityHealAbility(user,target,move,type,:ELECTRIC,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.add(:WATERABSORB,
proc { |ability,user,target,move,type,battle|
next pbBattleMoveImmunityHealAbility(user,target,move,type,:WATER,battle)
}
)
BattleHandlers::MoveImmunityTargetAbility.copy(:WATERABSORB,:DRYSKIN)
BattleHandlers::MoveImmunityTargetAbility.add(:WONDERGUARD,
proc { |ability,user,target,move,type,battle|
next false if move.statusMove?
next false if !type || PBTypeEffectiveness.superEffective?(target.damageState.typeMod)
battle.pbShowAbilitySplash(target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("It doesn't affect {1}...",target.pbThis(true)))
else
battle.pbDisplay(_INTL("{1} avoided damage with {2}!",target.pbThis,target.abilityName))
end
battle.pbHideAbilitySplash(target)
next true
}
)
#===============================================================================
# MoveBaseTypeModifierAbility handlers
#===============================================================================
BattleHandlers::MoveBaseTypeModifierAbility.add(:AERILATE,
proc { |ability,user,move,type|
next if type != :NORMAL || !GameData::Type.exists?(:FLYING)
move.powerBoost = true
next :FLYING
}
)
BattleHandlers::MoveBaseTypeModifierAbility.add(:GALVANIZE,
proc { |ability,user,move,type|
next if type != :NORMAL || !GameData::Type.exists?(:ELECTRIC)
move.powerBoost = true
next :ELECTRIC
}
)
BattleHandlers::MoveBaseTypeModifierAbility.add(:LIQUIDVOICE,
proc { |ability,user,move,type|
next :WATER if GameData::Type.exists?(:WATER) && move.soundMove?
}
)
BattleHandlers::MoveBaseTypeModifierAbility.add(:NORMALIZE,
proc { |ability,user,move,type|
next if !GameData::Type.exists?(:NORMAL)
move.powerBoost = true if Settings::MECHANICS_GENERATION >= 7
next :NORMAL
}
)
BattleHandlers::MoveBaseTypeModifierAbility.add(:PIXILATE,
proc { |ability,user,move,type|
next if type != :NORMAL || !GameData::Type.exists?(:FAIRY)
move.powerBoost = true
next :FAIRY
}
)
BattleHandlers::MoveBaseTypeModifierAbility.add(:REFRIGERATE,
proc { |ability,user,move,type|
next if type != :NORMAL || !GameData::Type.exists?(:ICE)
move.powerBoost = true
next :ICE
}
)
#===============================================================================
# AccuracyCalcUserAbility handlers
#===============================================================================
BattleHandlers::AccuracyCalcUserAbility.add(:COMPOUNDEYES,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_multiplier] *= 1.3
}
)
BattleHandlers::AccuracyCalcUserAbility.add(:HUSTLE,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_multiplier] *= 0.8 if move.physicalMove?
}
)
BattleHandlers::AccuracyCalcUserAbility.add(:KEENEYE,
proc { |ability,mods,user,target,move,type|
mods[:evasion_stage] = 0 if mods[:evasion_stage] > 0 && Settings::MECHANICS_GENERATION >= 6
}
)
BattleHandlers::AccuracyCalcUserAbility.add(:NOGUARD,
proc { |ability,mods,user,target,move,type|
mods[:base_accuracy] = 0
}
)
BattleHandlers::AccuracyCalcUserAbility.add(:UNAWARE,
proc { |ability,mods,user,target,move,type|
mods[:evasion_stage] = 0 if move.damagingMove?
}
)
BattleHandlers::AccuracyCalcUserAbility.add(:VICTORYSTAR,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_multiplier] *= 1.1
}
)
#===============================================================================
# AccuracyCalcUserAllyAbility handlers
#===============================================================================
BattleHandlers::AccuracyCalcUserAllyAbility.add(:VICTORYSTAR,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_multiplier] *= 1.1
}
)
#===============================================================================
# AccuracyCalcTargetAbility handlers
#===============================================================================
BattleHandlers::AccuracyCalcTargetAbility.add(:LIGHTNINGROD,
proc { |ability,mods,user,target,move,type|
mods[:base_accuracy] = 0 if type == :ELECTRIC
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:NOGUARD,
proc { |ability,mods,user,target,move,type|
mods[:base_accuracy] = 0
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:SANDVEIL,
proc { |ability,mods,user,target,move,type|
mods[:evasion_multiplier] *= 1.25 if target.battle.pbWeather == :Sandstorm
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:SNOWCLOAK,
proc { |ability,mods,user,target,move,type|
mods[:evasion_multiplier] *= 1.25 if target.battle.pbWeather == :Hail
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:STORMDRAIN,
proc { |ability,mods,user,target,move,type|
mods[:base_accuracy] = 0 if type == :WATER
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:TANGLEDFEET,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_multiplier] /= 2 if target.effects[PBEffects::Confusion] > 0
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:UNAWARE,
proc { |ability,mods,user,target,move,type|
mods[:accuracy_stage] = 0 if move.damagingMove?
}
)
BattleHandlers::AccuracyCalcTargetAbility.add(:WONDERSKIN,
proc { |ability,mods,user,target,move,type|
if move.statusMove? && user.opposes?(target)
mods[:base_accuracy] = 0 if mods[:base_accuracy] > 50
end
}
)
#===============================================================================
# DamageCalcUserAbility handlers
#===============================================================================
BattleHandlers::DamageCalcUserAbility.add(:AERILATE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.2 if move.powerBoost
}
)
BattleHandlers::DamageCalcUserAbility.copy(:AERILATE,:PIXILATE,:REFRIGERATE,:GALVANIZE)
BattleHandlers::DamageCalcUserAbility.add(:ANALYTIC,
proc { |ability,user,target,move,mults,baseDmg,type|
if (target.battle.choices[target.index][0]!=:UseMove &&
target.battle.choices[target.index][0]!=:Shift) ||
target.movedThisRound?
mults[:base_damage_multiplier] *= 1.3
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:BLAZE,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.hp <= user.totalhp / 3 && type == :FIRE
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:DEFEATIST,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] /= 2 if user.hp <= user.totalhp / 2
}
)
BattleHandlers::DamageCalcUserAbility.add(:FLAREBOOST,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.burned? && move.specialMove?
mults[:base_damage_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:FLASHFIRE,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.effects[PBEffects::FlashFire] && type == :FIRE
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:FLOWERGIFT,
proc { |ability,user,target,move,mults,baseDmg,type|
if move.physicalMove? && [:Sun, :HarshSun].include?(user.battle.pbWeather)
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:GUTS,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.pbHasAnyStatus? && move.physicalMove?
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:HUGEPOWER,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] *= 2 if move.physicalMove?
}
)
BattleHandlers::DamageCalcUserAbility.copy(:HUGEPOWER,:PUREPOWER)
BattleHandlers::DamageCalcUserAbility.add(:HUSTLE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] *= 1.5 if move.physicalMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:IRONFIST,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.2 if move.punchingMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:MEGALAUNCHER,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.5 if move.pulseMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:MINUS,
proc { |ability,user,target,move,mults,baseDmg,type|
next if !move.specialMove?
user.eachAlly do |b|
next if !b.hasActiveAbility?([:MINUS, :PLUS])
mults[:attack_multiplier] *= 1.5
break
end
}
)
BattleHandlers::DamageCalcUserAbility.copy(:MINUS,:PLUS)
BattleHandlers::DamageCalcUserAbility.add(:NEUROFORCE,
proc { |ability,user,target,move,mults,baseDmg,type|
if PBTypeEffectiveness.superEffective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 1.25
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:OVERGROW,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.hp <= user.totalhp / 3 && type == :GRASS
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:RECKLESS,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.2 if move.recoilMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:RIVALRY,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.gender!=2 && target.gender!=2
if user.gender==target.gender
mults[:base_damage_multiplier] *= 1.25
else
mults[:base_damage_multiplier] *= 0.75
end
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:SANDFORCE,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.battle.pbWeather == :Sandstorm &&
[:ROCK, :GROUND, :STEEL].include?(type)
mults[:base_damage_multiplier] *= 1.3
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:SHEERFORCE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.3 if move.addlEffect > 0
}
)
BattleHandlers::DamageCalcUserAbility.add(:SLOWSTART,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] /= 2 if user.effects[PBEffects::SlowStart] > 0 && move.physicalMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:SOLARPOWER,
proc { |ability,user,target,move,mults,baseDmg,type|
if move.specialMove? && [:Sun, :HarshSun].include?(user.battle.pbWeather)
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:SNIPER,
proc { |ability,user,target,move,mults,baseDmg,type|
if target.damageState.critical
mults[:final_damage_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:STAKEOUT,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] *= 2 if target.battle.choices[target.index][0] == :SwitchOut
}
)
BattleHandlers::DamageCalcUserAbility.add(:STEELWORKER,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] *= 1.5 if type == :STEEL
}
)
BattleHandlers::DamageCalcUserAbility.add(:STRONGJAW,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.5 if move.bitingMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:SWARM,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.hp <= user.totalhp / 3 && type == :BUG
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:TECHNICIAN,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.index != target.index && move && move.id != :STRUGGLE &&
baseDmg * mults[:base_damage_multiplier] <= 60
mults[:base_damage_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:TINTEDLENS,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:final_damage_multiplier] *= 2 if PBTypeEffectiveness.resistant?(target.damageState.typeMod)
}
)
BattleHandlers::DamageCalcUserAbility.add(:TORRENT,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.hp <= user.totalhp / 3 && type == :WATER
mults[:attack_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:TOUGHCLAWS,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 4 / 3.0 if move.contactMove?
}
)
BattleHandlers::DamageCalcUserAbility.add(:TOXICBOOST,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.poisoned? && move.physicalMove?
mults[:base_damage_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcUserAbility.add(:WATERBUBBLE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:attack_multiplier] *= 2 if type == :WATER
}
)
#===============================================================================
# DamageCalcUserAllyAbility handlers
#===============================================================================
BattleHandlers::DamageCalcUserAllyAbility.add(:BATTERY,
proc { |ability,user,target,move,mults,baseDmg,type|
next if !move.specialMove?
mults[:final_damage_multiplier] *= 1.3
}
)
BattleHandlers::DamageCalcUserAllyAbility.add(:FLOWERGIFT,
proc { |ability,user,target,move,mults,baseDmg,type|
if move.physicalMove? && [:Sun, :HarshSun].include?(user.battle.pbWeather)
mults[:attack_multiplier] *= 1.5
end
}
)
#===============================================================================
# DamageCalcTargetAbility handlers
#===============================================================================
BattleHandlers::DamageCalcTargetAbility.add(:DRYSKIN,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] *= 1.25 if type == :FIRE
}
)
BattleHandlers::DamageCalcTargetAbility.add(:FILTER,
proc { |ability,user,target,move,mults,baseDmg,type|
if PBTypeEffectiveness.superEffective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 0.75
end
}
)
BattleHandlers::DamageCalcTargetAbility.copy(:FILTER,:SOLIDROCK)
BattleHandlers::DamageCalcTargetAbility.add(:FLOWERGIFT,
proc { |ability,user,target,move,mults,baseDmg,type|
if move.specialMove? && [:Sun, :HarshSun].include?(user.battle.pbWeather)
mults[:defense_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcTargetAbility.add(:FLUFFY,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:final_damage_multiplier] *= 2 if move.calcType == :FIRE
mults[:final_damage_multiplier] /= 2 if move.contactMove?
}
)
BattleHandlers::DamageCalcTargetAbility.add(:FURCOAT,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:defense_multiplier] *= 2 if move.physicalMove? || move.function == "122" # Psyshock
}
)
BattleHandlers::DamageCalcTargetAbility.add(:GRASSPELT,
proc { |ability,user,target,move,mults,baseDmg,type|
if user.battle.field.terrain == :Grassy
mults[:defense_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcTargetAbility.add(:HEATPROOF,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] /= 2 if type == :FIRE
}
)
BattleHandlers::DamageCalcTargetAbility.add(:MARVELSCALE,
proc { |ability,user,target,move,mults,baseDmg,type|
if target.pbHasAnyStatus? && move.physicalMove?
mults[:defense_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcTargetAbility.add(:MULTISCALE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:final_damage_multiplier] /= 2 if target.hp == target.totalhp
}
)
BattleHandlers::DamageCalcTargetAbility.add(:THICKFAT,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:base_damage_multiplier] /= 2 if type == :FIRE || type == :ICE
}
)
BattleHandlers::DamageCalcTargetAbility.add(:WATERBUBBLE,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:final_damage_multiplier] /= 2 if type == :FIRE
}
)
#===============================================================================
# DamageCalcTargetAbilityNonIgnorable handlers
#===============================================================================
BattleHandlers::DamageCalcTargetAbilityNonIgnorable.add(:PRISMARMOR,
proc { |ability,user,target,move,mults,baseDmg,type|
if PBTypeEffectiveness.superEffective?(target.damageState.typeMod)
mults[:final_damage_multiplier] *= 0.75
end
}
)
BattleHandlers::DamageCalcTargetAbilityNonIgnorable.add(:SHADOWSHIELD,
proc { |ability,user,target,move,mults,baseDmg,type|
if target.hp==target.totalhp
mults[:final_damage_multiplier] /= 2
end
}
)
#===============================================================================
# DamageCalcTargetAllyAbility handlers
#===============================================================================
BattleHandlers::DamageCalcTargetAllyAbility.add(:FLOWERGIFT,
proc { |ability,user,target,move,mults,baseDmg,type|
if move.specialMove? && [:Sun, :HarshSun].include?(user.battle.pbWeather)
mults[:defense_multiplier] *= 1.5
end
}
)
BattleHandlers::DamageCalcTargetAllyAbility.add(:FRIENDGUARD,
proc { |ability,user,target,move,mults,baseDmg,type|
mults[:final_damage_multiplier] *= 0.75
}
)
#===============================================================================
# CriticalCalcUserAbility handlers
#===============================================================================
BattleHandlers::CriticalCalcUserAbility.add(:MERCILESS,
proc { |ability,user,target,c|
next 99 if target.poisoned?
}
)
BattleHandlers::CriticalCalcUserAbility.add(:SUPERLUCK,
proc { |ability,user,target,c|
next c+1
}
)
#===============================================================================
# CriticalCalcTargetAbility handlers
#===============================================================================
BattleHandlers::CriticalCalcTargetAbility.add(:BATTLEARMOR,
proc { |ability,user,target,c|
next -1
}
)
BattleHandlers::CriticalCalcTargetAbility.copy(:BATTLEARMOR,:SHELLARMOR)
#===============================================================================
# TargetAbilityOnHit handlers
#===============================================================================
BattleHandlers::TargetAbilityOnHit.add(:AFTERMATH,
proc { |ability,user,target,move,battle|
next if !target.fainted?
next if !move.pbContactMove?(user)
battle.pbShowAbilitySplash(target)
if !battle.moldBreaker
dampBattler = battle.pbCheckGlobalAbility(:DAMP)
if dampBattler
battle.pbShowAbilitySplash(dampBattler)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} cannot use {2}!",target.pbThis,target.abilityName))
else
battle.pbDisplay(_INTL("{1} cannot use {2} because of {3}'s {4}!",
target.pbThis,target.abilityName,dampBattler.pbThis(true),dampBattler.abilityName))
end
battle.pbHideAbilitySplash(dampBattler)
battle.pbHideAbilitySplash(target)
next
end
end
if user.takesIndirectDamage?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
battle.scene.pbDamageAnimation(user)
user.pbReduceHP(user.totalhp/4,false)
battle.pbDisplay(_INTL("{1} was caught in the aftermath!",user.pbThis))
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:ANGERPOINT,
proc { |ability,user,target,move,battle|
next if !target.damageState.critical
next if !target.pbCanRaiseStatStage?(PBStats::ATTACK,target)
battle.pbShowAbilitySplash(target)
target.stages[PBStats::ATTACK] = 6
battle.pbCommonAnimation("StatUp",target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} maxed its {2}!",target.pbThis,PBStats.getName(PBStats::ATTACK)))
else
battle.pbDisplay(_INTL("{1}'s {2} maxed its {3}!",
target.pbThis,target.abilityName,PBStats.getName(PBStats::ATTACK)))
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:CURSEDBODY,
proc { |ability,user,target,move,battle|
next if user.fainted?
next if user.effects[PBEffects::Disable]>0
regularMove = nil
user.eachMove do |m|
next if m.id!=user.lastRegularMoveUsed
regularMove = m
break
end
next if !regularMove || (regularMove.pp==0 && regularMove.total_pp>0)
next if battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(target)
if !move.pbMoveFailedAromaVeil?(target,user,PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
user.effects[PBEffects::Disable] = 3
user.effects[PBEffects::DisableMove] = regularMove.id
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s {2} was disabled!",user.pbThis,regularMove.name))
else
battle.pbDisplay(_INTL("{1}'s {2} was disabled by {3}'s {4}!",
user.pbThis,regularMove.name,target.pbThis(true),target.abilityName))
end
battle.pbHideAbilitySplash(target)
user.pbItemStatusCureCheck
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:CUTECHARM,
proc { |ability,user,target,move,battle|
next if target.fainted?
next if !move.pbContactMove?(user)
next if battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(target)
if user.pbCanAttract?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} made {3} fall in love!",target.pbThis,
target.abilityName,user.pbThis(true))
end
user.pbAttract(target,msg)
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:EFFECTSPORE,
proc { |ability,user,target,move,battle|
# NOTE: This ability has a 30% chance of triggering, not a 30% chance of
# inflicting a status condition. It can try (and fail) to inflict a
# status condition that the user is immune to.
next if !move.pbContactMove?(user)
next if battle.pbRandom(100)>=30
r = battle.pbRandom(3)
next if r==0 && user.asleep?
next if r==1 && user.poisoned?
next if r==2 && user.paralyzed?
battle.pbShowAbilitySplash(target)
if user.affectedByPowder?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
case r
when 0
if user.pbCanSleep?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} made {3} fall asleep!",target.pbThis,
target.abilityName,user.pbThis(true))
end
user.pbSleep(msg)
end
when 1
if user.pbCanPoison?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} poisoned {3}!",target.pbThis,
target.abilityName,user.pbThis(true))
end
user.pbPoison(target,msg)
end
when 2
if user.pbCanParalyze?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} paralyzed {3}! It may be unable to move!",
target.pbThis,target.abilityName,user.pbThis(true))
end
user.pbParalyze(target,msg)
end
end
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:FLAMEBODY,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
next if user.burned? || battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(target)
if user.pbCanBurn?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} burned {3}!",target.pbThis,target.abilityName,user.pbThis(true))
end
user.pbBurn(target,msg)
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:GOOEY,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
user.pbLowerStatStageByAbility(PBStats::SPEED,1,target,true,true)
}
)
BattleHandlers::TargetAbilityOnHit.copy(:GOOEY,:TANGLINGHAIR)
BattleHandlers::TargetAbilityOnHit.add(:ILLUSION,
proc { |ability,user,target,move,battle|
# NOTE: This intentionally doesn't show the ability splash.
next if !target.effects[PBEffects::Illusion]
target.effects[PBEffects::Illusion] = nil
battle.scene.pbChangePokemon(target,target.pokemon)
battle.pbDisplay(_INTL("{1}'s illusion wore off!",target.pbThis))
battle.pbSetSeen(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:INNARDSOUT,
proc { |ability,user,target,move,battle|
next if !target.fainted? || user.dummy
battle.pbShowAbilitySplash(target)
if user.takesIndirectDamage?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
battle.scene.pbDamageAnimation(user)
user.pbReduceHP(target.damageState.hpLost,false)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} is hurt!",user.pbThis))
else
battle.pbDisplay(_INTL("{1} is hurt by {2}'s {3}!",user.pbThis,
target.pbThis(true),target.abilityName))
end
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:IRONBARBS,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
battle.pbShowAbilitySplash(target)
if user.takesIndirectDamage?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
battle.scene.pbDamageAnimation(user)
user.pbReduceHP(user.totalhp/8,false)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} is hurt!",user.pbThis))
else
battle.pbDisplay(_INTL("{1} is hurt by {2}'s {3}!",user.pbThis,
target.pbThis(true),target.abilityName))
end
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.copy(:IRONBARBS,:ROUGHSKIN)
BattleHandlers::TargetAbilityOnHit.add(:JUSTIFIED,
proc { |ability,user,target,move,battle|
next if move.calcType != :DARK
target.pbRaiseStatStageByAbility(PBStats::ATTACK,1,target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:MUMMY,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
next if user.fainted?
next if user.unstoppableAbility? || user.ability == ability
oldAbil = -1
battle.pbShowAbilitySplash(target) if user.opposes?(target)
if user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
oldAbil = user.ability
battle.pbShowAbilitySplash(user,true,false) if user.opposes?(target)
user.ability = ability
battle.pbReplaceAbilitySplash(user) if user.opposes?(target)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s Ability became {2}!",user.pbThis,user.abilityName))
else
battle.pbDisplay(_INTL("{1}'s Ability became {2} because of {3}!",
user.pbThis,user.abilityName,target.pbThis(true)))
end
battle.pbHideAbilitySplash(user) if user.opposes?(target)
end
battle.pbHideAbilitySplash(target) if user.opposes?(target)
user.pbOnAbilityChanged(oldAbil) if oldAbil>=0
}
)
BattleHandlers::TargetAbilityOnHit.add(:POISONPOINT,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
next if user.poisoned? || battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(target)
if user.pbCanPoison?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} poisoned {3}!",target.pbThis,target.abilityName,user.pbThis(true))
end
user.pbPoison(target,msg)
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:RATTLED,
proc { |ability,user,target,move,battle|
next if ![:BUG, :DARK, :GHOST].include?(move.calcType)
target.pbRaiseStatStageByAbility(PBStats::SPEED,1,target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:STAMINA,
proc { |ability,user,target,move,battle|
target.pbRaiseStatStageByAbility(PBStats::DEFENSE,1,target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:STATIC,
proc { |ability,user,target,move,battle|
next if !move.pbContactMove?(user)
next if user.paralyzed? || battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(target)
if user.pbCanParalyze?(target,PokeBattle_SceneConstants::USE_ABILITY_SPLASH) &&
user.affectedByContactEffect?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} paralyzed {3}! It may be unable to move!",
target.pbThis,target.abilityName,user.pbThis(true))
end
user.pbParalyze(target,msg)
end
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:WATERCOMPACTION,
proc { |ability,user,target,move,battle|
next if move.calcType != :WATER
target.pbRaiseStatStageByAbility(PBStats::DEFENSE,2,target)
}
)
BattleHandlers::TargetAbilityOnHit.add(:WEAKARMOR,
proc { |ability,user,target,move,battle|
next if !move.physicalMove?
next if !target.pbCanLowerStatStage?(PBStats::DEFENSE, target) &&
!target.pbCanRaiseStatStage?(PBStats::SPEED, target)
battle.pbShowAbilitySplash(target)
target.pbLowerStatStageByAbility(PBStats::DEFENSE, 1, target, false)
target.pbRaiseStatStageByAbility(PBStats::SPEED,
(Settings::MECHANICS_GENERATION >= 7) ? 2 : 1, target, false)
battle.pbHideAbilitySplash(target)
}
)
#===============================================================================
# UserAbilityOnHit handlers
#===============================================================================
BattleHandlers::UserAbilityOnHit.add(:POISONTOUCH,
proc { |ability,user,target,move,battle|
next if !move.contactMove?
next if battle.pbRandom(100)>=30
battle.pbShowAbilitySplash(user)
if target.hasActiveAbility?(:SHIELDDUST) && !battle.moldBreaker
battle.pbShowAbilitySplash(target)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} is unaffected!",target.pbThis))
end
battle.pbHideAbilitySplash(target)
elsif target.pbCanPoison?(user,PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
msg = nil
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
msg = _INTL("{1}'s {2} poisoned {3}!",user.pbThis,user.abilityName,target.pbThis(true))
end
target.pbPoison(user,msg)
end
battle.pbHideAbilitySplash(user)
}
)
#===============================================================================
# UserAbilityEndOfMove handlers
#===============================================================================
BattleHandlers::UserAbilityEndOfMove.add(:BEASTBOOST,
proc { |ability,user,targets,move,battle|
next if battle.pbAllFainted?(user.idxOpposingSide)
numFainted = 0
targets.each { |b| numFainted += 1 if b.damageState.fainted }
next if numFainted==0
userStats = user.plainStats
highestStatValue = userStats.max
PBStats.eachMainBattleStat do |s|
next if userStats[s]<highestStatValue
if user.pbCanRaiseStatStage?(s,user)
user.pbRaiseStatStageByAbility(s,numFainted,user)
end
break
end
}
)
BattleHandlers::UserAbilityEndOfMove.add(:MAGICIAN,
proc { |ability,user,targets,move,battle|
next if battle.futureSight
next if !move.pbDamagingMove?
next if user.item
next if battle.wildBattle? && user.opposes?
targets.each do |b|
next if b.damageState.unaffected || b.damageState.substitute
next if !b.item
next if b.unlosableItem?(b.item) || user.unlosableItem?(b.item)
battle.pbShowAbilitySplash(user)
if b.hasActiveAbility?(:STICKYHOLD)
battle.pbShowAbilitySplash(b) if user.opposes?(b)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s item cannot be stolen!",b.pbThis))
end
battle.pbHideAbilitySplash(b) if user.opposes?(b)
next
end
user.item = b.item
b.item = nil
b.effects[PBEffects::Unburden] = true
if battle.wildBattle? && !user.initialItem && b.initialItem==user.item
user.setInitialItem(user.item)
b.setInitialItem(nil)
end
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} stole {2}'s {3}!",user.pbThis,
b.pbThis(true),user.itemName))
else
battle.pbDisplay(_INTL("{1} stole {2}'s {3} with {4}!",user.pbThis,
b.pbThis(true),user.itemName,user.abilityName))
end
battle.pbHideAbilitySplash(user)
user.pbHeldItemTriggerCheck
break
end
}
)
BattleHandlers::UserAbilityEndOfMove.add(:MOXIE,
proc { |ability,user,targets,move,battle|
next if battle.pbAllFainted?(user.idxOpposingSide)
numFainted = 0
targets.each { |b| numFainted += 1 if b.damageState.fainted }
next if numFainted==0 || !user.pbCanRaiseStatStage?(PBStats::ATTACK,user)
user.pbRaiseStatStageByAbility(PBStats::ATTACK,numFainted,user)
}
)
#===============================================================================
# TargetAbilityAfterMoveUse handlers
#===============================================================================
BattleHandlers::TargetAbilityAfterMoveUse.add(:BERSERK,
proc { |ability,target,user,move,switched,battle|
next if !move.damagingMove?
next if target.damageState.initialHP<target.totalhp/2 || target.hp>=target.totalhp/2
next if !target.pbCanRaiseStatStage?(PBStats::SPATK,target)
target.pbRaiseStatStageByAbility(PBStats::SPATK,1,target)
}
)
BattleHandlers::TargetAbilityAfterMoveUse.add(:COLORCHANGE,
proc { |ability,target,user,move,switched,battle|
next if target.damageState.calcDamage==0 || target.damageState.substitute
next if !move.calcType || PBTypes.isPseudoType?(move.calcType)
next if target.pbHasType?(move.calcType) && !target.pbHasOtherType?(move.calcType)
typeName = GameData::Type.get(move.calcType).name
battle.pbShowAbilitySplash(target)
target.pbChangeTypes(move.calcType)
battle.pbDisplay(_INTL("{1}'s {2} made it the {3} type!",target.pbThis,
target.abilityName,typeName))
battle.pbHideAbilitySplash(target)
}
)
BattleHandlers::TargetAbilityAfterMoveUse.add(:PICKPOCKET,
proc { |ability,target,user,move,switched,battle|
# NOTE: According to Bulbapedia, this can still trigger to steal the user's
# item even if it was switched out by a Red Card. This doesn't make
# sense, so this code doesn't do it.
next if battle.wildBattle? && target.opposes?
next if !move.contactMove?
next if switched.include?(user.index)
next if user.effects[PBEffects::Substitute]>0 || target.damageState.substitute
next if target.item || !user.item
next if user.unlosableItem?(user.item) || target.unlosableItem?(user.item)
battle.pbShowAbilitySplash(target)
if user.hasActiveAbility?(:STICKYHOLD)
battle.pbShowAbilitySplash(user) if target.opposes?(user)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s item cannot be stolen!",user.pbThis))
end
battle.pbHideAbilitySplash(user) if target.opposes?(user)
battle.pbHideAbilitySplash(target)
next
end
target.item = user.item
user.item = nil
user.effects[PBEffects::Unburden] = true
if battle.wildBattle? && !target.initialItem && user.initialItem==target.item
target.setInitialItem(target.item)
user.setInitialItem(nil)
end
battle.pbDisplay(_INTL("{1} pickpocketed {2}'s {3}!",target.pbThis,
user.pbThis(true),target.itemName))
battle.pbHideAbilitySplash(target)
target.pbHeldItemTriggerCheck
}
)
#===============================================================================
# EORWeatherAbility handlers
#===============================================================================
BattleHandlers::EORWeatherAbility.add(:DRYSKIN,
proc { |ability,weather,battler,battle|
case weather
when :Sun, :HarshSun
battle.pbShowAbilitySplash(battler)
battle.scene.pbDamageAnimation(battler)
battler.pbReduceHP(battler.totalhp/8,false)
battle.pbDisplay(_INTL("{1} was hurt by the sunlight!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
battler.pbItemHPHealCheck
when :Rain, :HeavyRain
next if !battler.canHeal?
battle.pbShowAbilitySplash(battler)
battler.pbRecoverHP(battler.totalhp/8)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s HP was restored.",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} restored its HP.",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
end
}
)
BattleHandlers::EORWeatherAbility.add(:ICEBODY,
proc { |ability,weather,battler,battle|
next unless weather == :Hail
next if !battler.canHeal?
battle.pbShowAbilitySplash(battler)
battler.pbRecoverHP(battler.totalhp/16)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s HP was restored.",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} restored its HP.",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::EORWeatherAbility.add(:RAINDISH,
proc { |ability,weather,battler,battle|
next unless [:Rain, :HeavyRain].include?(weather)
next if !battler.canHeal?
battle.pbShowAbilitySplash(battler)
battler.pbRecoverHP(battler.totalhp/16)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1}'s HP was restored.",battler.pbThis))
else
battle.pbDisplay(_INTL("{1}'s {2} restored its HP.",battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::EORWeatherAbility.add(:SOLARPOWER,
proc { |ability,weather,battler,battle|
next unless [:Sun, :HarshSun].include?(weather)
battle.pbShowAbilitySplash(battler)
battle.scene.pbDamageAnimation(battler)
battler.pbReduceHP(battler.totalhp/8,false)
battle.pbDisplay(_INTL("{1} was hurt by the sunlight!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
battler.pbItemHPHealCheck
}
)
#===============================================================================
# EORHealingAbility handlers
#===============================================================================
BattleHandlers::EORHealingAbility.add(:HEALER,
proc { |ability,battler,battle|
next unless battle.pbRandom(100)<30
battler.eachAlly do |b|
next if b.status == :NONE
battle.pbShowAbilitySplash(battler)
oldStatus = b.status
b.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
case oldStatus
when :SLEEP
battle.pbDisplay(_INTL("{1}'s {2} woke its partner up!",battler.pbThis,battler.abilityName))
when :POISON
battle.pbDisplay(_INTL("{1}'s {2} cured its partner's poison!",battler.pbThis,battler.abilityName))
when :BURN
battle.pbDisplay(_INTL("{1}'s {2} healed its partner's burn!",battler.pbThis,battler.abilityName))
when :PARALYSIS
battle.pbDisplay(_INTL("{1}'s {2} cured its partner's paralysis!",battler.pbThis,battler.abilityName))
when :FROZEN
battle.pbDisplay(_INTL("{1}'s {2} defrosted its partner!",battler.pbThis,battler.abilityName))
end
end
battle.pbHideAbilitySplash(battler)
end
}
)
BattleHandlers::EORHealingAbility.add(:HYDRATION,
proc { |ability,battler,battle|
next if battler.status == :NONE
next if ![:Rain, :HeavyRain].include?(battle.pbWeather)
battle.pbShowAbilitySplash(battler)
oldStatus = battler.status
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
case oldStatus
when :SLEEP
battle.pbDisplay(_INTL("{1}'s {2} woke it up!",battler.pbThis,battler.abilityName))
when :POISON
battle.pbDisplay(_INTL("{1}'s {2} cured its poison!",battler.pbThis,battler.abilityName))
when :BURN
battle.pbDisplay(_INTL("{1}'s {2} healed its burn!",battler.pbThis,battler.abilityName))
when :PARALYSIS
battle.pbDisplay(_INTL("{1}'s {2} cured its paralysis!",battler.pbThis,battler.abilityName))
when :FROZEN
battle.pbDisplay(_INTL("{1}'s {2} defrosted it!",battler.pbThis,battler.abilityName))
end
end
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::EORHealingAbility.add(:SHEDSKIN,
proc { |ability,battler,battle|
next if battler.status == :NONE
next unless battle.pbRandom(100)<30
battle.pbShowAbilitySplash(battler)
oldStatus = battler.status
battler.pbCureStatus(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
case oldStatus
when :SLEEP
battle.pbDisplay(_INTL("{1}'s {2} woke it up!",battler.pbThis,battler.abilityName))
when :POISON
battle.pbDisplay(_INTL("{1}'s {2} cured its poison!",battler.pbThis,battler.abilityName))
when :BURN
battle.pbDisplay(_INTL("{1}'s {2} healed its burn!",battler.pbThis,battler.abilityName))
when :PARALYSIS
battle.pbDisplay(_INTL("{1}'s {2} cured its paralysis!",battler.pbThis,battler.abilityName))
when :FROZEN
battle.pbDisplay(_INTL("{1}'s {2} defrosted it!",battler.pbThis,battler.abilityName))
end
end
battle.pbHideAbilitySplash(battler)
}
)
#===============================================================================
# EOREffectAbility handlers
#===============================================================================
BattleHandlers::EOREffectAbility.add(:BADDREAMS,
proc { |ability,battler,battle|
battle.eachOtherSideBattler(battler.index) do |b|
next if !b.near?(battler) || !b.asleep?
battle.pbShowAbilitySplash(battler)
next if !b.takesIndirectDamage?(PokeBattle_SceneConstants::USE_ABILITY_SPLASH)
oldHP = b.hp
b.pbReduceHP(b.totalhp/8)
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} is tormented!",b.pbThis))
else
battle.pbDisplay(_INTL("{1} is tormented by {2}'s {3}!",b.pbThis,
battler.pbThis(true),battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
b.pbItemHPHealCheck
b.pbAbilitiesOnDamageTaken(oldHP)
b.pbFaint if b.fainted?
end
}
)
BattleHandlers::EOREffectAbility.add(:MOODY,
proc { |ability,battler,battle|
randomUp = []; randomDown = []
PBStats.eachBattleStat do |s|
randomUp.push(s) if battler.pbCanRaiseStatStage?(s,battler)
randomDown.push(s) if battler.pbCanLowerStatStage?(s,battler)
end
next if randomUp.length==0 && randomDown.length==0
battle.pbShowAbilitySplash(battler)
if randomUp.length>0
r = battle.pbRandom(randomUp.length)
battler.pbRaiseStatStageByAbility(randomUp[r],2,battler,false)
randomDown.delete(randomUp[r])
end
if randomDown.length>0
r = battle.pbRandom(randomDown.length)
battler.pbLowerStatStageByAbility(randomDown[r],1,battler,false)
end
battle.pbHideAbilitySplash(battler)
battler.pbItemStatRestoreCheck if randomDown.length>0
}
)
BattleHandlers::EOREffectAbility.add(:SPEEDBOOST,
proc { |ability,battler,battle|
# A Pokémon's turnCount is 0 if it became active after the beginning of a
# round
if battler.turnCount>0 && battler.pbCanRaiseStatStage?(PBStats::SPEED,battler)
battler.pbRaiseStatStageByAbility(PBStats::SPEED,1,battler)
end
}
)
#===============================================================================
# EORGainItemAbility handlers
#===============================================================================
BattleHandlers::EORGainItemAbility.add(:HARVEST,
proc { |ability,battler,battle|
next if battler.item
next if !battler.recycleItem || !GameData::Item.get(battler.recycleItem).is_berry?
if ![:Sun, :HarshSun].include?(battle.pbWeather)
next unless battle.pbRandom(100)<50
end
battle.pbShowAbilitySplash(battler)
battler.item = battler.recycleItem
battler.setRecycleItem(nil)
battler.setInitialItem(battler.item) if !battler.initialItem
battle.pbDisplay(_INTL("{1} harvested one {2}!",battler.pbThis,battler.itemName))
battle.pbHideAbilitySplash(battler)
battler.pbHeldItemTriggerCheck
}
)
BattleHandlers::EORGainItemAbility.add(:PICKUP,
proc { |ability,battler,battle|
next if battler.item
foundItem = nil; fromBattler = nil; use = 0
battle.eachBattler do |b|
next if b.index==battler.index
next if b.effects[PBEffects::PickupUse]<=use
foundItem = b.effects[PBEffects::PickupItem]
fromBattler = b
use = b.effects[PBEffects::PickupUse]
end
next if !foundItem
battle.pbShowAbilitySplash(battler)
battler.item = foundItem
fromBattler.effects[PBEffects::PickupItem] = nil
fromBattler.effects[PBEffects::PickupUse] = 0
fromBattler.setRecycleItem(nil) if fromBattler.recycleItem==foundItem
if battle.wildBattle? && !battler.initialItem && fromBattler.initialItem==foundItem
battler.setInitialItem(foundItem)
fromBattler.setInitialItem(nil)
end
battle.pbDisplay(_INTL("{1} found one {2}!",battler.pbThis,battler.itemName))
battle.pbHideAbilitySplash(battler)
battler.pbHeldItemTriggerCheck
}
)
#===============================================================================
# CertainSwitchingUserAbility handlers
#===============================================================================
# There aren't any!
#===============================================================================
# TrappingTargetAbility handlers
#===============================================================================
BattleHandlers::TrappingTargetAbility.add(:ARENATRAP,
proc { |ability,switcher,bearer,battle|
next true if !switcher.airborne?
}
)
BattleHandlers::TrappingTargetAbility.add(:MAGNETPULL,
proc { |ability,switcher,bearer,battle|
next true if switcher.pbHasType?(:STEEL)
}
)
BattleHandlers::TrappingTargetAbility.add(:SHADOWTAG,
proc { |ability,switcher,bearer,battle|
next true if !switcher.hasActiveAbility?(:SHADOWTAG)
}
)
#===============================================================================
# AbilityOnSwitchIn handlers
#===============================================================================
BattleHandlers::AbilityOnSwitchIn.add(:AIRLOCK,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
if !PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} has {2}!",battler.pbThis,battler.abilityName))
end
battle.pbDisplay(_INTL("The effects of the weather disappeared."))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.copy(:AIRLOCK,:CLOUDNINE)
BattleHandlers::AbilityOnSwitchIn.add(:ANTICIPATION,
proc { |ability,battler,battle|
next if !battler.pbOwnedByPlayer?
battlerTypes = battler.pbTypes(true)
type1 = battlerTypes[0]
type2 = battlerTypes[1] || type1
type3 = battlerTypes[2] || type2
found = false
battle.eachOtherSideBattler(battler.index) do |b|
b.eachMove do |m|
next if m.statusMove?
if type1
moveType = m.type
if Settings::MECHANICS_GENERATION >= 6 && m.function == "090" # Hidden Power
moveType = pbHiddenPower(b.pokemon)[0]
end
eff = PBTypes.getCombinedEffectiveness(moveType,type1,type2,type3)
next if PBTypeEffectiveness.ineffective?(eff)
next if !PBTypeEffectiveness.superEffective?(eff) && m.function != "070" # OHKO
else
next if m.function != "070" # OHKO
end
found = true
break
end
break if found
end
if found
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} shuddered with anticipation!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
end
}
)
BattleHandlers::AbilityOnSwitchIn.add(:AURABREAK,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} reversed all other Pokémon's auras!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:COMATOSE,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is drowsing!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DARKAURA,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is radiating a dark aura!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DELTASTREAM,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:StrongWinds, battler, battle, true)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DESOLATELAND,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:HarshSun, battler, battle, true)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DOWNLOAD,
proc { |ability,battler,battle|
oDef = oSpDef = 0
battle.eachOtherSideBattler(battler.index) do |b|
oDef += b.defense
oSpDef += b.spdef
end
stat = (oDef<oSpDef) ? PBStats::ATTACK : PBStats::SPATK
battler.pbRaiseStatStageByAbility(stat,1,battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DRIZZLE,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:Rain, battler, battle)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:DROUGHT,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:Sun, battler, battle)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:ELECTRICSURGE,
proc { |ability,battler,battle|
next if battle.field.terrain == :Electric
battle.pbShowAbilitySplash(battler)
battle.pbStartTerrain(battler, :Electric)
# NOTE: The ability splash is hidden again in def pbStartTerrain.
}
)
BattleHandlers::AbilityOnSwitchIn.add(:FAIRYAURA,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is radiating a fairy aura!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:FOREWARN,
proc { |ability,battler,battle|
next if !battler.pbOwnedByPlayer?
highestPower = 0
forewarnMoves = []
battle.eachOtherSideBattler(battler.index) do |b|
b.eachMove do |m|
power = m.baseDamage
power = 160 if ["070"].include?(m.function) # OHKO
power = 150 if ["08B"].include?(m.function) # Eruption
# Counter, Mirror Coat, Metal Burst
power = 120 if ["071","072","073"].include?(m.function)
# Sonic Boom, Dragon Rage, Night Shade, Endeavor, Psywave,
# Return, Frustration, Crush Grip, Gyro Ball, Hidden Power,
# Natural Gift, Trump Card, Flail, Grass Knot
power = 80 if ["06A","06B","06D","06E","06F",
"089","08A","08C","08D","090",
"096","097","098","09A"].include?(m.function)
next if power<highestPower
forewarnMoves = [] if power>highestPower
forewarnMoves.push(m.name)
highestPower = power
end
end
if forewarnMoves.length>0
battle.pbShowAbilitySplash(battler)
forewarnMoveName = forewarnMoves[battle.pbRandom(forewarnMoves.length)]
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} was alerted to {2}!",
battler.pbThis, forewarnMoveName))
else
battle.pbDisplay(_INTL("{1}'s Forewarn alerted it to {2}!",
battler.pbThis, forewarnMoveName))
end
battle.pbHideAbilitySplash(battler)
end
}
)
BattleHandlers::AbilityOnSwitchIn.add(:FRISK,
proc { |ability,battler,battle|
next if !battler.pbOwnedByPlayer?
foes = []
battle.eachOtherSideBattler(battler.index) do |b|
foes.push(b) if b.item
end
if foes.length>0
battle.pbShowAbilitySplash(battler)
if Settings::MECHANICS_GENERATION >= 6
foes.each do |b|
battle.pbDisplay(_INTL("{1} frisked {2} and found its {3}!",
battler.pbThis,b.pbThis(true),b.itemName))
end
else
foe = foes[battle.pbRandom(foes.length)]
battle.pbDisplay(_INTL("{1} frisked the foe and found one {2}!",
battler.pbThis,foe.itemName))
end
battle.pbHideAbilitySplash(battler)
end
}
)
BattleHandlers::AbilityOnSwitchIn.add(:GRASSYSURGE,
proc { |ability,battler,battle|
next if battle.field.terrain == :Grassy
battle.pbShowAbilitySplash(battler)
battle.pbStartTerrain(battler, :Grassy)
# NOTE: The ability splash is hidden again in def pbStartTerrain.
}
)
BattleHandlers::AbilityOnSwitchIn.add(:IMPOSTER,
proc { |ability,battler,battle|
next if battler.effects[PBEffects::Transform]
choice = battler.pbDirectOpposing
next if choice.fainted?
next if choice.effects[PBEffects::Transform] ||
choice.effects[PBEffects::Illusion] ||
choice.effects[PBEffects::Substitute]>0 ||
choice.effects[PBEffects::SkyDrop]>=0 ||
choice.semiInvulnerable?
battle.pbShowAbilitySplash(battler,true)
battle.pbHideAbilitySplash(battler)
battle.pbAnimation(:TRANSFORM,battler,choice)
battle.scene.pbChangePokemon(battler,choice.pokemon)
battler.pbTransform(choice)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:INTIMIDATE,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.eachOtherSideBattler(battler.index) do |b|
next if !b.near?(battler)
b.pbLowerAttackStatStageIntimidate(battler)
b.pbItemOnIntimidatedCheck
end
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:MISTYSURGE,
proc { |ability,battler,battle|
next if battle.field.terrain == :Misty
battle.pbShowAbilitySplash(battler)
battle.pbStartTerrain(battler, :Misty)
# NOTE: The ability splash is hidden again in def pbStartTerrain.
}
)
BattleHandlers::AbilityOnSwitchIn.add(:MOLDBREAKER,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} breaks the mold!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:PRESSURE,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is exerting its pressure!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:PRIMORDIALSEA,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:HeavyRain, battler, battle, true)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:PSYCHICSURGE,
proc { |ability,battler,battle|
next if battle.field.terrain == :Psychic
battle.pbShowAbilitySplash(battler)
battle.pbStartTerrain(battler, :Psychic)
# NOTE: The ability splash is hidden again in def pbStartTerrain.
}
)
BattleHandlers::AbilityOnSwitchIn.add(:SANDSTREAM,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:Sandstorm, battler, battle)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:SLOWSTART,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battler.effects[PBEffects::SlowStart] = 5
if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
battle.pbDisplay(_INTL("{1} can't get it going!",battler.pbThis))
else
battle.pbDisplay(_INTL("{1} can't get it going because of its {2}!",
battler.pbThis,battler.abilityName))
end
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:SNOWWARNING,
proc { |ability,battler,battle|
pbBattleWeatherAbility(:Hail, battler, battle)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:TERAVOLT,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is radiating a bursting aura!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:TURBOBLAZE,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is radiating a blazing aura!",battler.pbThis))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityOnSwitchIn.add(:UNNERVE,
proc { |ability,battler,battle|
battle.pbShowAbilitySplash(battler)
battle.pbDisplay(_INTL("{1} is too nervous to eat Berries!",battler.pbOpposingTeam))
battle.pbHideAbilitySplash(battler)
}
)
#===============================================================================
# AbilityOnSwitchOut handlers
#===============================================================================
BattleHandlers::AbilityOnSwitchOut.add(:NATURALCURE,
proc { |ability,battler,endOfBattle|
PBDebug.log("[Ability triggered] #{battler.pbThis}'s #{battler.abilityName}")
battler.status = :NONE
}
)
BattleHandlers::AbilityOnSwitchOut.add(:REGENERATOR,
proc { |ability,battler,endOfBattle|
next if endOfBattle
PBDebug.log("[Ability triggered] #{battler.pbThis}'s #{battler.abilityName}")
battler.pbRecoverHP(battler.totalhp/3,false,false)
}
)
#===============================================================================
# AbilityChangeOnBattlerFainting handlers
#===============================================================================
BattleHandlers::AbilityChangeOnBattlerFainting.add(:POWEROFALCHEMY,
proc { |ability,battler,fainted,battle|
next if battler.opposes?(fainted)
next if fainted.ungainableAbility? ||
[:POWEROFALCHEMY, :RECEIVER, :TRACE, :WONDERGUARD].include?(fainted.ability_id)
battle.pbShowAbilitySplash(battler,true)
battler.ability = fainted.ability
battle.pbReplaceAbilitySplash(battler)
battle.pbDisplay(_INTL("{1}'s {2} was taken over!",fainted.pbThis,fainted.abilityName))
battle.pbHideAbilitySplash(battler)
}
)
BattleHandlers::AbilityChangeOnBattlerFainting.copy(:POWEROFALCHEMY,:RECEIVER)
#===============================================================================
# AbilityOnBattlerFainting handlers
#===============================================================================
BattleHandlers::AbilityOnBattlerFainting.add(:SOULHEART,
proc { |ability,battler,fainted,battle|
battler.pbRaiseStatStageByAbility(PBStats::SPATK,1,battler)
}
)
#===============================================================================
# RunFromBattleAbility handlers
#===============================================================================
BattleHandlers::RunFromBattleAbility.add(:RUNAWAY,
proc { |ability,battler|
next true
}
)
Reference in New Issue View Git Blame Copy Permalink