PhoenixDex Moves Function Codes

#Vanilla Essentials:
#battler starts at 117
#battler position starts at 8
#Side starts at 22
#Both sides starts at 13
module PBEffects
  #===========================================================================
  # These effects apply to a battler
  #===========================================================================
  CatchBoost          = 117
  Corrode             = 118
  Deaf                = 119
  GermSprayUse        = 120
  PlagueStormUse      = 121
  Quicksand           = 122
  RingOfFire          = 123
  Stoke               = 124
  #=============================================================================
  # These effects apply to a battler position
  #=============================================================================
  AfterShock                = 8
  #=============================================================================
  # These effects apply to a side
  #=============================================================================
  DustGuard       = 21
  OilSlick        = 22
  RainbowWall     = 23
  #=============================================================================
  # These effects apply to the battle (i.e. both sides)
  #=============================================================================
  Clangor         = 13
  GardenType      = 14
  GardenCount     = 15
end

#===============================================================================
# Decreases the target's Special Defense by 1 stage. Accuracy perfect in rain. (Acid Rain)
#===============================================================================
class Battle::Move::LowerTargetSpDef1AlwaysHitsInRain < Battle::Move::LowerTargetSpDef1
  def pbBaseAccuracy(user, target)
    case target.effectiveWeather
    when :Rain, :HeavyRain
      return 0
    end
    return super
  end
end
#===============================================================================
# Power increases with the user's coolness. (Amaze and Dragon Dive)
#===============================================================================
class Battle::Move::PowerHigherWithUserCoolness < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [(user.cool / 3).floor, 1].max
  end
end
#===============================================================================
# Two turn attack. Skips first turn, attacks second turn. Is invulnerable during
# use. Ends target's protections upon hit. (Backstab)
#===============================================================================
class Battle::Move::TwoTurnAttackInvulnerableAlwaysCriticalHit < Battle::Move::TwoTurnMove
  def pbChargingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} disappeared into shadow!", user.pbThis))
  end

  def pbCritialOverride(user, target); return 1; end
end
#===============================================================================
# Increases the target's Attack and Special Attack by 2 stages each. (Battle Cry)
#===============================================================================
class Battle::Move::RaiseTargetAtkSpAtk1 < Battle::Move
  def pbMoveFailed?(user, targets)
    failed = true
    targets.each do |b|
      next if !b.pbCanRaiseStatStage?(:ATTACK, user, self) &&
              !b.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self)
      failed = false
      break
    end
    if failed
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    if target.pbCanRaiseStatStage?(:ATTACK, user, self)
      target.pbRaiseStatStage(:ATTACK, 1, user)
    end
    if target.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self)
      target.pbRaiseStatStage(:SPECIAL_ATTACK, 1, user)
    end
  end
end
#===============================================================================
# User consumes held berry, restored 1/4HP, and gains its effect. (Berry Juicer)
#===============================================================================
class Battle::Move::UserConsumeHeldBerryRestoreQuarterTotalHP < Battle::Move
  def healingMove?;       return true; end
  def canSnatch?;         return true; end

  def pbCanChooseMove?(user, commandPhase, showMessages)
    item = user.item
    if !item || !item.is_berry? || !user.itemActive? || !user.canConsumeBerry?
      if showMessages
        msg = _INTL("{1} can't use that move because it doesn't have a Berry!", user.pbThis)
        (commandPhase) ? @battle.pbDisplayPaused(msg) : @battle.pbDisplay(msg)
      end
      return false
    end
    return true
  end

  def pbMoveFailed?(user, targets)
    item = user.item
    if !item || !item.is_berry? || !user.itemActive? || !user.canConsumeBerry?
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return super
  end

  def pbEffectGeneral(user)
    super
    @battle.pbDisplay(_INTL("{1} ate its {2}!", user.pbThis, user.itemName))
    item = user.item
    user.pbConsumeItem(true, false)   # Don't trigger Symbiosis yet
    user.pbHeldItemTriggerCheck(item, false)
    user.pbRecoverHP((user.totalhp / 4.0).round)
    @battle.pbDisplay(_INTL("{1}'s HP was restored.", user.pbThis))
  end
end
#===============================================================================
# Power is doubled if the target is affected by a mental non-volatile condition.
# (Bewitch)
#===============================================================================
class Battle::Move::DoublePowerIfUserMentalEffect < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    if target.effects[PBEffects::Confusion] > 0 ||
       target.effects[PBEffects::Curse] ||
       target.effects[PBEffects::Embargo] > 0 ||
       target.effects[PBEffects::Encore] > 0 ||
       target.effects[PBEffects::HealBlock] > 0 ||
       target.effects[PBEffects::Foresight] ||
       target.effects[PBEffects::Attract] >= 0 ||
       target.effects[PBEffects::Nightmare] ||
       target.effects[PBEffects::PerishSong] > 0 ||
       target.effects[PBEffects::Telekinesis] > 0 ||
       target.effects[PBEffects::Taunt] > 0 ||
       target.effects[PBEffects::Torment] ||
       target.trappedInBattle?
      baseDmg *= 2
    end
    return baseDmg
  end
end
#===============================================================================
# Power increases with the target's base Special Attack. (Brain Press)
#===============================================================================
class Battle::Move::PowerHigherWithTargetSpAtk < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [[(target.spatk / 2).floor, 1].max,150].min
  end
end
#===============================================================================
# Decreases the target's Defense by 1 stage, raises user's Attack by one stage. (Bravado)
#===============================================================================
class Battle::Move::LowerTargetDefense1RaiseUserAttack1 < Battle::Move::TargetStatDownMove
  def initialize(battle, move)
    super
    @statDown = [:DEFENSE, 1]
  end
end
#===============================================================================
# User faints unless Pay Day is in effect,
# even if the move does nothing else. (Break the Bank)
#===============================================================================
class Battle::Move::UserFaintsExplosiveUnlessPayday < Battle::Move
  def worksWithNoTargets?;     return true; end
  def pbNumHits(user, targets); return 1;    end

  def pbMoveFailed?(user, targets)
    if !@battle.moldBreaker
      bearer = @battle.pbCheckGlobalAbility(:DAMP)
      if bearer
        @battle.pbShowAbilitySplash(bearer)
        if Battle::Scene::USE_ABILITY_SPLASH
          @battle.pbDisplay(_INTL("{1} cannot use {2}!", user.pbThis, @name))
        else
          @battle.pbDisplay(_INTL("{1} cannot use {2} because of {3}'s {4}!",
                                  user.pbThis, @name, bearer.pbThis(true), bearer.abilityName))
        end
        @battle.pbHideAbilitySplash(bearer)
        return true
      end
    end
    return false
  end

  def pbSelfKO(user)
    return if user.fainted?
    if @field.effects[PBEffects::PayDay] > 0
        @field.effects[PBEffects::PayDay] = 0
        @battle.pbDisplay(_INTL("{1} used the energy of coins on the field!", user.pbThis))
    else
        user.pbReduceHP(user.hp, false)
        user.pbItemHPHealCheck
    end
  end
end
#===============================================================================
# Two turn attack. Skips first turn, attacks second turn. Burns the target.
# If user has Flame Body ability, takes 1 turn instead. (Burning Strike)
#===============================================================================
class Battle::Move::TwoTurnAttackOneTurnFlameBodyBurnTarget < Battle::Move::TwoTurnMove
  def pbIsChargingTurn?(user)
    ret = super
    if !user.effects[PBEffects::TwoTurnAttack] &&
       user.hasActiveAbility?(:FLAMEBODY)
      @powerHerb = false
      @chargingTurn = true
      @damagingTurn = true
      return false
    end
    return ret
  end

  def pbChargingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} built up heat!", user.pbThis))
  end

  def pbEffectAgainstTarget(user, target)
    return if damagingMove?
    target.pbBurn(user)
  end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    target.pbBurn(user) if target.pbCanBurn?(user, false, self)
  end

end
#===============================================================================
# Target becomes Rock type. (Calcify)
#===============================================================================
class Battle::Move::SetTargetTypesToRock < Battle::Move
  def canMagicCoat?; return true; end

  def pbFailsAgainstTarget?(user, target, show_message)
    if !target.canChangeType? || !GameData::Type.exists?(:ROCK) ||
       !target.pbHasOtherType?(:ROCK)
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    target.pbChangeTypes(:ROCK)
    typeName = GameData::Type.get(:ROCK).name
    @battle.pbDisplay(_INTL("{1}'s type changed to {2}!", target.pbThis, typeName))
  end
end
#===============================================================================
# The target's ally loses 1/16 of its max HP. Can hit targets underwater. (Cannonball)
#===============================================================================
class Battle::Move::DamageTargetAllyDoublePowerIfTargetUnderwater < Battle::Move
  def hitsDivingTargets?; return true; end

  def pbModifyDamage(damageMult, user, target)
    damageMult *= 2 if target.inTwoTurnAttack?("TwoTurnAttackInvulnerableUnderwater")
    return damageMult
  end

  def pbEffectWhenDealingDamage(user, target)
    hitAlly = []
    target.allAllies.each do |b|
      next if !b.near?(target.index)
      next if !b.takesIndirectDamage?
      hitAlly.push([b.index, b.hp])
      b.pbReduceHP(b.totalhp / 16, false)
    end
    if hitAlly.length == 2
      @battle.pbDisplay(_INTL("The splashing wave hit {1} and {2}!",
                              @battle.battlers[hitAlly[0][0]].pbThis(true),
                              @battle.battlers[hitAlly[1][0]].pbThis(true)))
    elsif hitAlly.length > 0
      hitAlly.each do |b|
        @battle.pbDisplay(_INTL("The splashing wave hit {1}!",
                                @battle.battlers[b[0]].pbThis(true)))
      end
    end
    hitAlly.each { |b| @battle.battlers[b[0]].pbItemHPHealCheck }
  end
end
#===============================================================================
# Heals user by an amount depending on the weather, with Rain being favored. (Clear Rain)
#===============================================================================
class Battle::Move::HealUserDependingOnRain < Battle::Move::HealingMove
  def pbOnStartUse(user, targets)
    case user.effectiveWeather
    when :Rain, :HeavyRain
      @healAmount = (user.totalhp * 2 / 3.0).round
    when :None
      @healAmount = (user.totalhp / 2.0).round
    else
      @healAmount = (user.totalhp / 4.0).round
    end
  end

  def pbHealAmount(user)
    return @healAmount
  end
end
#===============================================================================
# Clears any active weather. (Clear Sky)
#===============================================================================
class Battle::Move::ClearWeather < Battle::Move::WeatherMove
  def initialize(battle, move)
    super
    @weatherType = :None
  end
end
#===============================================================================
# Hits 2-5 times. If Payday has been used, doubles in power but clears the coins.
# (Coin Shot)
#===============================================================================
class Battle::Move::HitTwoToFiveTimesPaydayPowerUp < Battle::Move::HitTwoToFiveTimes

  def pbBaseDamage(baseDmg, user, target)
    if @field.effects[PBEffects::PayDay] > 0
        @field.effects[PBEffects::PayDay] = 0
        @battle.pbDisplay(_INTL("{1} used the energy of coins on the field!", user.pbThis))
        baseDmg *= 2
    end
    return baseDmg
  end

end
#===============================================================================
# Resets all target's positive stat stages to 0. (Cold Shower and Face Slap)
#===============================================================================
class Battle::Move::ResetTargetPositiveStatStages < Battle::Move
  def pbEffectAgainstTarget(user, target)
    if !target.damageState.substitute && target.hasRaisedStatStages?
      GameData::Stat.each_battle do |s|
        next if target.stages[s.id] <= 0
        target.statsLoweredThisRound = true
        target.statsDropped = true
        target.stages[s.id] = 0
      end
      @battle.pbDisplay(_INTL("{1}'s positive stat changes were removed!", target.pbThis))
    end
  end
end
#===============================================================================
# Power increases if the user has eaten a berry. Chance to flinch. (Compost Bomb)
#===============================================================================
class Battle::Move::FlinchTargetIncreasePowerIfUserConsumedBerry < Battle::FlinchTarget
  def pbBaseDamage(baseDmg, user, target)
    baseDmg *= 1.5 if user.belched?
    return baseDmg
  end
end
#===============================================================================
# Power increases with the user's cleverness. (Confound and Phantasmata)
#===============================================================================
class Battle::Move::PowerHigherWithUserSmart < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [(user.smart/ 3).floor, 1].max
  end
end
#===============================================================================
# Target's positive Defense/Sp. Def stages set to 0. (Corrode)
# Poison moves have normal effectiveness against the Steel-type target.
#===============================================================================
class Battle::Move::RemovePositiveDefenseStagesNegateSteelImmunity < Battle::Move
  def canMagicCoat?;            return true; end
  def ignoresSubstitute?(user); return true; end

  def pbEffectAgainstTarget(user, target)
    if target.stages[:DEFENSE] > 0
       target.stages[:DEFENSE] = 0
       target.statsLoweredThisRound = true
    end
    if target.stages[:SPECIAL_DEFENSE] > 0
       target.stages[:SPECIAL_DEFENSE] = 0
       target.statsLoweredThisRound = true
    end
    target.effects[PBEffects::Corrode] = true
    @battle.pbDisplay(_INTL("{1}'s defenses were corroded!", target.pbThis))
  end
end

#===============================================================================
# Increases the user's Attack and Sp. Attack by 1 stage each.
# In a sandstorm or hailstorm, increases are 2 stages each instead. (Crystallize)
#===============================================================================
class Battle::Move::RaiseUserDefSpDef1Or2InHailSand < Battle::Move::MultiStatUpMove
  def initialize(battle, move)
    super
    @statUp = [:DEFENSE, 1, :SPECIAL_DEFENSE, 1]
  end

  def pbOnStartUse(user, targets)
    increment = 1
    increment = 2 if [:Sandstorm, :Hail].include?(user.effectiveWeather)
    @statUp[1] = @statUp[3] = increment
  end
end
#===============================================================================
# Power increases with the user's cuteness. (Dazzle and Prism Shower)
#===============================================================================
class Battle::Move::PowerHigherWithUserCuteness < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [(user.cute / 3).floor, 1].max
  end
end
#===============================================================================
# Power increases with the user's toughness. (Demolish and Wild Maul)
#===============================================================================
class Battle::Move::PowerHigherWithUserToughness < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [(user.tough / 3).floor, 1].max
  end
end
#===============================================================================
# Type effectiveness is multiplied by the Flying-type's effectiveness against
# the target. Chance to paralyze the target. May cause the target to flinch. (Destroyer Driver)
#===============================================================================
class Battle::Move::EffectivenessIncludesDarkTypeParalyzeFlinchTarget < Battle::Move
  def flinchingMove?; return true; end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    chance = pbAdditionalEffectChance(user, target, 10)
    return if chance == 0
    if target.pbCanParalyze?(user, false, self) && @battle.pbRandom(100) < chance
      target.pbParalyze(user)
    end
    target.pbFlinch(user) if @battle.pbRandom(100) < chance
  end

  def pbCalcTypeModSingle(moveType, defType, user, target)
    ret = super
    if GameData::Type.exists?(:DARK)
      darkEff = Effectiveness.calculate_one(:DARK, defType)
      ret *= darkEff.to_f / Effectiveness::NORMAL_EFFECTIVE_ONE
    end
    return ret
  end

end
#===============================================================================
# Two turn attack. Skips first turn, attacks second turn. (Drag Under)
# (Handled in Battler's pbSuccessCheckPerHit): Is semi-invulnerable during use.
# Target is also semi-invulnerable during use, and can't take any action.
# Doesn't damage Water-type Pokémon (but still makes them unable to move during).
#===============================================================================
class Battle::Move::TwoTurnAttackInvulnerableUnderwaterTargetCannotAct < Battle::Move::TwoTurnMove

  def pbIsChargingTurn?(user)
    # NOTE: Drag Under doesn't benefit from Power Herb, probably because it works
    #       differently (i.e. immobilises the target during use too).
    @powerHerb = false
    @chargingTurn = (user.effects[PBEffects::TwoTurnAttack].nil?)
    @damagingTurn = (!user.effects[PBEffects::TwoTurnAttack].nil?)
    return !@damagingTurn
  end

  def pbFailsAgainstTarget?(user, target, show_message)
    if !target.opposes?(user)
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    if target.effects[PBEffects::Substitute] > 0 && !ignoresSubstitute?(user)
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    if Settings::MECHANICS_GENERATION >= 6 && target.pbWeight >= 2000   # 200.0kg
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    if target.semiInvulnerable? ||
       (target.effects[PBEffects::DragUnder] >= 0 && @chargingTurn)
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    if target.effects[PBEffects::DragUnder] != user.index && @damagingTurn
      @battle.pbDisplay(_INTL("But it failed!")) if show_message
      return true
    end
    return false
  end

  def pbCalcTypeMod(movetype, user, target)
    return Effectiveness::INEFFECTIVE if target.pbHasType?(:WATER)
    return super
  end

  def pbChargingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} took {2} underwater!", user.pbThis, targets[0].pbThis(true)))
  end

  def pbAttackingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} was freed from Drag Under!", targets[0].pbThis))
  end

  def pbChargingTurnEffect(user, target)
    target.effects[PBEffects::SkyDrop] = user.index
  end

  def pbAttackingTurnEffect(user, target)
    target.effects[PBEffects::SkyDrop] = -1
  end
end
#===============================================================================
# For 5 rounds, prevents moves' additional effects against user's side. (Dust Guard)
#===============================================================================
class Battle::Move::StartPreventAddEffectsAgainstUserSide < Battle::Move
  def canSnatch?; return true; end

  def pbMoveFailed?(user, targets)
    if user.pbOwnSide.effects[PBEffects::DustGuard] > 0
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    user.pbOwnSide.effects[PBEffects::DustGuard] = 5
    @battle.pbDisplay(_INTL("{1} protected {2} from moves' additional effects!", @name, user.pbTeam(true)))
  end
end
#===============================================================================
# Target is deafened, and unaffected by sound moves for the rest of the turn.
# (Ear Splitter)
#===============================================================================
class Battle::Move::DeafenTarget < Battle::Move

  def pbEffectAgainstTarget(user, target)
    return if damagingMove?
    target.effects[PBEffects::Deaf] = 2
    @battle.pbDisplay(_INTL("{1} was deafened!", target.pbThis))
  end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    target.effects[PBEffects::Deaf] = 2
    @battle.pbDisplay(_INTL("{1} was deafened!", target.pbThis))
  end
end
#===============================================================================
# Paralyzes or burns the target. (Electroburn)
#===============================================================================
class Battle::Move::ParalyzeOrBurnTarget < Battle::Move
  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    case @battle.pbRandom(2)
    when 0 then target.pbBurn(user) if target.pbCanBurn?(user, false, self)
    when 1 then target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
    end
  end
end
#===============================================================================
# Power increases with the user's beauty. (Enthrall and Elegant Wave)
#===============================================================================
class Battle::Move::PowerHigherWithUserBeauty < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    return [(user.beauty / 3).floor, 1].max
  end
end
#===============================================================================
# Increases the user's Sp. Attack and Speed by 1 stage each.
# (Fairy Dance)
#===============================================================================
class Battle::Move::RaiseUserSpAtkSpd1 < Battle::Move::MultiStatUpMove
  def initialize(battle, move)
    super
    @statUp = [:SPECIAL_ATTACK, 1, :SPEED, 1]
  end
end
#===============================================================================
# Decreases one random stat of the target by 2 stages (except HP). (Fairy Jinx)
#===============================================================================
class Battle::Move::LowerTargetRandomStat2 < Battle::Move
  def pbFailsAgainstTarget?(user, target, show_message)
    @statArray = []
    GameData::Stat.each_battle do |s|
      @statArray.push(s.id) if target.pbCanLowerStatStage?(s.id, user, self)
    end
    return false if damagingMove?
    if @statArray.length == 0
      @battle.pbDisplay(_INTL("{1}'s stats won't go any lower!", target.pbThis)) if show_message
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    stat = @statArray[@battle.pbRandom(@statArray.length)]
    target.pbLowerStatStage(stat, 2, user)
  end
end
#===============================================================================
# Increases target's Speed by 1 stage. (Fanfare)
#===============================================================================
class Battle::Move::RaiseTargetSpeed1 < Battle::Move
  def ignoresSubstitute?(user); return true; end

  def pbFailsAgainstTarget?(user, target, show_message)
    return true if !target.pbCanRaiseStatStage?(:SPEED, user, self, show_message)
    return false
  end

  def pbEffectAgainstTarget(user, target)
    target.pbRaiseStatStage(:SPEED, 1, user)
  end
end
#===============================================================================
# Decreases the target's Special Attack by 1 stage and burns it. (Fiery Charm)
#===============================================================================
class Battle::Move::BurnTargetLowerTargetSpAtk1 < Battle::Move::TargetStatDownMove
  def initialize(battle, move)
    super
    @statDown = [:SPECIAL_ATTACK, 1]
  end
  def pbAdditionalEffect(user, target)
    super
    return if target.damageState.substitute
    target.pbBurn(user) if target.pbCanBurn?(user, false, self)
  end
end
#===============================================================================
# Decreases the target's Special Attack and Special Defense by 1 stage each. (Ghostly Touch)
#===============================================================================
class Battle::Move::LowerTargetSpAtkSpDef1 < Battle::Move::TargetMultiStatDownMove
  def initialize(battle, move)
    super
    @statDown = [:SPECIAL_ATTACK, 1, :SPECIAL_DEFENSE, 1]
  end
end
#===============================================================================
# Two turn attack. Skips first turn, attacks second turn. (Glacier Rush)
# Power halved in all weather except hail. In haik, takes 1 turn instead.
#===============================================================================
class Battle::Move::TwoTurnAttackOneTurnInHail < Battle::Move::TwoTurnMove
  def pbIsChargingTurn?(user)
    ret = super
    if !user.effects[PBEffects::TwoTurnAttack] &&
       [:Hail].include?(user.effectiveWeather)
      @powerHerb = false
      @chargingTurn = true
      @damagingTurn = true
      return false
    end
    return ret
  end

  def pbChargingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} built up snow and ice!", user.pbThis))
  end

  def pbBaseDamageMultiplier(damageMult, user, target)
    damageMult /= 2 if ![:None, :Hail].include?(user.effectiveWeather)
    return damageMult
  end
end
#===============================================================================
# For 5 rounds, creates a misty terrain which weakens Fighting- and Normal-type moves
# and increases effect chance of moves. Affects non-airborne Pokémon only.
# (Haunted Terrain)
#===============================================================================
class Battle::Move::StartHauntedTerrain < Battle::Move
  def pbMoveFailed?(user, targets)
    if @battle.field.terrain == :Haunted
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    @battle.pbStartTerrain(user, :Haunted)
  end
end
#===============================================================================
# User gains stat stages equal to each of the target's positive stat stages,
# and target's positive stat stages become 0, then lowers Special Defense.
# (Heart Snare)
#===============================================================================
class Battle::Move::UserStealTargetPositiveStatStagesLowerTargetSpDef1 < Battle::Move
#  def ignoresSubstitute?(user); return true; end

  def pbFailsAgainstTarget?(user, target, show_message)
    return (!target.hasRaisedStatStages?) && !(target.pbCanLowerStatStage?(:SPECIAL_DEFENSE, user, self))
  end

  def pbEffectAgainstTarget(user, target)
    if target.hasRaisedStatStages?
      pbShowAnimation(@id, user, target, 1)   # Stat stage-draining animation
      @battle.pbDisplay(_INTL("{1} stole the target's boosted stats!", user.pbThis))
      showAnim = true
      GameData::Stat.each_battle do |s|
        next if target.stages[s.id] <= 0
        if user.pbCanRaiseStatStage?(s.id, user, self)
          showAnim = false if user.pbRaiseStatStage(s.id, target.stages[s.id], user, showAnim)
        end
        target.statsLoweredThisRound = true
        target.statsDropped = true
        target.stages[s.id] = 0
      end
    end
    if target.pbCanLowerStatStage?(:SPECIAL_DEFENSE, user, self)
        target.pbLowerStatStage(:SPECIAL_DEFENSE, 1 user, self)
    end
  end

end
#================================================================================
# Increases the user's Attack by 1 stage for every team member
# with a status effect/fainted. (Hero Rally)
#================================================================================
class Battle::Move::RaiseUserAttackPerAiledTeamMember < Battle::Move
  def canSnatch?; return true; end

  def pbMoveFailed?(user, targets)
    return false if damagingMove?
    @heroRallyList = []
    @battle.eachInTeamFromBattlerIndex(user.index) do |pkmn|
      @heroRallyList.push(pkmn) if (!pkmn.able? || pkmn.status != :NONE) && (pkmn != user)
    end
    if @heroRallyList.length == 0
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbFailsAgainstTarget?(user, target, show_message)
    return false if damagingMove?
    return !target.pbCanRaiseStatStage?(:ATTACK, user, self, show_message)
  end

  def pbEffectAgainstTarget(user, target)
    return if damagingMove?
    target.pbRaiseStatStage(:ATTACK, @heroRallyList.length, user)
  end

  def pbAdditionalEffect(user, target)
    return if !target.pbCanRaiseStatStage?(:ATTACK, user, self)
    target.pbRaiseStatStage(:ATTACK, @heroRallyList.length, user)
  end
end
#===============================================================================
# Increases the user's Attack and accuracy by 1 stage each. (Hyper-Focus)
#===============================================================================
class Battle::Move::RaiseUserSpAtkAcc1 < Battle::Move::MultiStatUpMove
  def initialize(battle, move)
    super
    @statUp = [:SPECIAL_ATTACK, 1, :ACCURACY, 1]
  end
end
#===============================================================================
# Power is doubled if the target is frozen. Thaws the target out. (Ice Drill)
#===============================================================================
class Battle::Move::DoublePowerIfTargetFrozenCureTarget < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    if target.asleep? &&
       (target.effects[PBEffects::Substitute] == 0 || ignoresSubstitute?(user))
      baseDmg *= 2
    end
    return baseDmg
  end

  def pbEffectAfterAllHits(user, target)
    return if target.fainted?
    return if target.damageState.unaffected || target.damageState.substitute
    return if target.status != :FROZEN
    target.pbCureStatus
  end
end
#===============================================================================
# Increases the target's Attack and Speed by 1 stage each. (Invigorate)
#===============================================================================
class Battle::Move::RaiseTargetAtkSpeed1 < Battle::Move
  def pbMoveFailed?(user, targets)
    failed = true
    targets.each do |b|
      next if !b.pbCanRaiseStatStage?(:ATTACK, user, self) &&
              !b.pbCanRaiseStatStage?(:SPEED, user, self)
      failed = false
      break
    end
    if failed
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    if target.pbCanRaiseStatStage?(:ATTACK, user, self)
      target.pbRaiseStatStage(:ATTACK, 1, user)
    end
    if target.pbCanRaiseStatStage?(:SPEED, user, self)
      target.pbRaiseStatStage(:SPEED, 1, user)
    end
  end
end
#===============================================================================
# User must use this move for 2 or 3 more rounds. Target becomes trapped.
# (Jaw Thrash)
#===============================================================================
class Battle::Move::MultiTurnAttackTrapTargetInBattle < Battle::Move
  def pbEffectAfterAllHits(user, target)
    if !target.damageState.unaffected && user.effects[PBEffects::Outrage] == 0
      user.effects[PBEffects::Outrage] = 3 + @battle.pbRandom(2)
      user.currentMove = @id
      target.effects[PBEffects::MeanLook] = user.index
    end
    if user.effects[PBEffects::Outrage] > 0
      user.effects[PBEffects::Outrage] -= 1
      if user.effects[PBEffects::Outrage] == 0
        target.effects[PBEffects::MeanLook] = 0
        @battle.pbDisplay(_INTL("{1} was freed from {2}'s jaws!",target.pbThis,user.pbThis))
      end
    end
  end
end

#===============================================================================
# Decreases one random stat of the target by 1 stage (except HP). (Jewel Blast)
#===============================================================================
class Battle::Move::LowerTargetRandomStat1 < Battle::TargetStatDownMove
  def pbFailsAgainstTarget?(user, target, show_message)
    @statArray = []
    GameData::Stat.each_battle do |s|
      @statArray.push(s.id) if target.pbCanLowerStatStage?(s.id, user, self)
    end
    return false if damagingMove?
    if @statArray.length == 0
      @battle.pbDisplay(_INTL("{1}'s stats won't go any lower!", target.pbThis)) if show_message
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    stat = @statArray[@battle.pbRandom(@statArray.length)]
    target.pbLowerStatStage(stat, 1, user)
  end
end
#===============================================================================
# Increases the target's Special Attack and Speed by 1 stage each. (Jump-Start)
#===============================================================================
class Battle::Move::RaiseTargetSpAtkSpeed1 < Battle::Move
  def pbMoveFailed?(user, targets)
    failed = true
    targets.each do |b|
      next if !b.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self) &&
              !b.pbCanRaiseStatStage?(:SPEED, user, self)
      failed = false
      break
    end
    if failed
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    if target.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self)
      target.pbRaiseStatStage(:SPECIAL_ATTACK, 1, user)
    end
    if target.pbCanRaiseStatStage?(:SPEED, user, self)
      target.pbRaiseStatStage(:SPEED, 1, user)
    end
  end
end
#===================================================================================
# Power is doubled if the target has the Dark, Dragon, or Fairy type. (Knight Sword)
#===================================================================================
class Battle::Move::DoublePowerIfTargetDarkDragonFairy < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    baseDmg *= 2 if target.pbHasType?(:DARK) || target.pbHasType?(:DRAGON) || target.pbHasType?(:FAIRY)
    return baseDmg
  end
end
#===============================================================================
# Cancels all multi-turn moves. (Lariat)
#===============================================================================
class Battle::Move::StopTargetMultiTurnMove < Battle::Move

  def pbEffectAgainstTarget(user, target)
    if target.effects[PBEffects::TwoTurnAttack] || target.effects[PBEffects::Outrage] > 0 ||
        target.effects[PBEffects::Rollout] > 0
        target.effects[PBEffects::TwoTurnAttack] = nil
        target.effects[PBEffects::Outrage] = 0
        target.effects[PBEffects::Rollout] = 0
        @battle.pbClearChoice(target.index) if !target.movedThisRound?
    end
    @battle.pbDisplay(_INTL("{1}'s attack was disrupted!", target.pbThis))
  end
end
#===============================================================================
# Power increases for every ally with a status effect/fainted.
# (Last Stand, Phoenix Fire, Retribution)
#===============================================================================
class Battle::Move::PowerHigherWithAiledTeamMember < Battle::Move
  def pbBaseDamage(baseDmg, user, target)
    @battle.eachInTeamFromBattlerIndex(user.index) do |pkmn|
      baseDmg += 20 if (!pkmn.able? || pkmn.status != :NONE) && (pkmn != user)
    end
    return baseDmg
  end
end
#==================================================================================
# For 5 rounds, surrounds the battle with a garden of Mental Herbs. (Mental Garden)
#==================================================================================
class Battle::Move::StartMentalGarden < Battle::Move
  def pbMoveFailed?(user, targets)
    if @battle.field.effects[PBEffects::GardenType] == "Mental"
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    if @battle.field.effects[PBEffects::GardenCount] > 0
        #pbCommonAnimation("GardenWilt")
        @battle.pbDisplay(_INTL("The last garden wilted..."))
    end
    @battle.field.effects[PBEffects::GardenType] = "Mental"
    @battle.field.effects[PBEffects::GardenCount] = 5
    @battle.pbDisplay(_INTL("A garden of Mental Herbs bloomed around the battlefield!"))
  end

end
#===============================================================================
# For 5 rounds, creates a miasma terrain which boosts Poison-type moves and damages
# Pokémon at the end of each round. Affects non-airborne Pokémon only.
# (Miasma Terrain)
#===============================================================================
class Battle::Move::StartMiasmaTerrain < Battle::Move
  def pbMoveFailed?(user, targets)
    if @battle.field.terrain == :Miasma
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    @battle.pbStartTerrain(user, :Miasma)
  end
end
#===============================================================================
# Ignores all abilities that alter this move's success or damage.
# (Handled in Battler_UseMoveTriggerEffects's pbEffectsOnMakingHit):
# Ignores all items that alter this move's success or damage.
# (Moonbeam Lance, Spire Lance, Stinger Lance, Winter Lance)
#===============================================================================
class Battle::Move::IgnoreTargetAbilityAndItem < Battle::Move
  def pbChangeUsageCounters(user, specialUsage)
    super
    @battle.moldBreaker = true if !specialUsage
  end
end
#===============================================================================
# User takes recoil damage equal to 1/2 of the damage this move dealt.
# May paralyze the target. (Mow Down)
#===============================================================================
class Battle::Move::RecoilHalfOfDamageDealtParalyzeTarget < Battle::Move::RecoilMove
  def pbRecoilDamage(user, target)
    return (target.damageState.totalHPLost / 2.0).round
  end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
  end
end
#===============================================================================
# Target flinches and is deafened. (Noise Blast)
#===============================================================================
class Battle::Move::FlinchDeafenTarget < Battle::Move::FlinchTarget

  def pbEffectAgainstTarget(user, target)
    super
    target.effects[PBEffects::Deaf] = 2
    @battle.pbDisplay(_INTL("{1} was deafened!", target.pbThis))
  end
end
#===============================================================================
# Entry hazard. Lays oil slick on the opposing side. (Oil Slick)
#===============================================================================
class Battle::Move::AddOilSlickToFoeSide < Battle::Move
  def canMagicCoat?; return true; end

  def pbMoveFailed?(user, targets)
    if user.pbOpposingSide.effects[PBEffects::OilSlick] > 0
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    user.pbOpposingSide.effects[PBEffects::OilSlick] = 5
    @battle.pbDisplay(_INTL("Oil spilled in front of {1}!",
                            user.pbOpposingTeam(true)))
  end
end
#===============================================================================
# Uses a random move that the target knows. (Parodize)
#===============================================================================
class Battle::Move::UseRandomTargetMove < Battle::Move
  def ignoresSubstitute?(user); return true; end
  def callsAnotherMove?; return true; end

  def initialize(battle, move)
    super
    @moveBlacklist = [
      # Struggle, Belch
      "Struggle",                                          # Struggle
      "FailsIfUserNotConsumedBerry",                       # Belch
      # Moves that affect the moveset
      "ReplaceMoveThisBattleWithTargetLastMoveUsed",       # Mimic
      "ReplaceMoveWithTargetLastMoveUsed",                 # Sketch
      "TransformUserIntoTarget",                           # Transform         #Not listed on PhoenixDex
      # Counter moves
      "CounterPhysicalDamage",                             # Counter
      "CounterSpecialDamage",                              # Mirror Coat
      "CounterDamagePlusHalf",                             # Metal Burst        # Not listed on Bulbapedia/PhoenixDex
      # Helping Hand, Feint (always blacklisted together, don't know why)
      "PowerUpAllyMove",                                   # Helping Hand
      "RemoveProtections",                                 # Feint
      # Protection moves
      "ProtectUser",                                       # Detect, Protect
      "ProtectUserSideFromPriorityMoves",                  # Quick Guard        # Not listed on Bulbapedia for Copycat
      "ProtectUserSideFromMultiTargetDamagingMoves",       # Wide Guard         # Not listed on Bulbapedia for Copycat
      "UserEnduresFaintingThisTurn",                       # Endure
      "ProtectUserSideFromDamagingMovesIfUserFirstTurn",   # Mat Block
      "ProtectUserSideFromStatusMoves",                    # Crafty Shield      # Not listed on Bulbapedia/PhoenixDex
      "ProtectUserFromDamagingMovesKingsShield",           # King's Shield
      "ProtectUserFromTargetingMovesSpikyShield",          # Spiky Shield
      "ProtectUserBanefulBunker",                          # Baneful Bunker     #Not listed on PhoenixDex
      # Moves that call other moves
      "UseLastMoveUsedByTarget",                           # Mirror Move
      "UseLastMoveUsed",                                   # Copycat
      "UseMoveTargetIsAboutToUse",                         # Me First
      "UseRandomUserMoveIfAsleep",                         # Sleep Talk
      "UseRandomMoveFromUserParty",                        # Assist
      "UseRandomMove",                                     # Metronome
      "UseRandomTargetMove",                               # Parodize (this move)
      "UseMoveDependingOnEnvironment",                     # Nature Power       # Not listed on Bulbapedia or PhoenixDex
      # Target-switching moves
      "SwitchOutTargetStatusMove",                         # Roar, Whirlwind
      "SwitchOutTargetDamagingMove",                       # Circle Throw, Dragon Tail
      # Move-redirecting and stealing moves
      "BounceBackProblemCausingStatusMoves",               # Magic Coat         # Not listed on Bulbapedia/PhoenixDex
      "StealAndUseBeneficialStatusMove",                   # Snatch
      "RedirectAllMovesToUser",                            # Follow Me, Rage Powder
      "RedirectAllMovesToTarget",                          # Spotlight          #Not listed on PhoenixDex
      # Set up effects that trigger upon KO
      "ReduceAttackerMovePPTo0IfUserFaints",               # Grudge             # Not listed on Bulbapedia/PhoenixDex
      "AttackerFaintsIfUserFaints",                        # Destiny Bond
      # Held item-moving moves
      "UserTakesTargetItem",                               # Covet, Thief
      "UserTargetSwapItems",                               # Switcheroo, Trick
      #"TargetTakesUserItem",                              # Bestow              #Not listed on PhoenixDex
      # Moves that start focussing at the start of the round
      "FailsIfUserDamagedThisTurn",                        # Focus Punch
      "UsedAfterUserTakesPhysicalDamage",                  # Shell Trap          #Not listed on PhoenixDex
      "BurnAttackerBeforeUserActs",                        # Beak Blast          #Not listed on PhoenixDex
      # Event moves that do nothing
      "DoesNothingFailsIfNoAlly",                          # Hold Hands          #Not listed on PhoenixDex
      "DoesNothingCongratulations"                         # Celebrate           #Not listed on PhoenixDex
      # Two-turn attacks
      "TwoTurnAttackInvulnerableInSky",                  # Fly
      "TwoTurnAttackInvulnerableUnderground",            # Dig
      "TwoTurnAttackInvulnerableUnderwater",             # Dive
      "TwoTurnAttackInvulnerableRemoveProtections",      # Shadow Force/Phantom Force
#      "TwoTurnAttack",                                   # Razor Wind                # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackOneTurnInSun",                       # Solar Beam, Solar Blade   # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackParalyzeTarget",                     # Freeze Shock              # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackBurnTarget",                         # Ice Burn                  # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackFlinchTarget",                       # Sky Attack                # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackChargeRaiseUserDefense1",            # Skull Bash                # Not listed on Bulbapedia/PhoenixDex
#      "TwoTurnAttackInvulnerableInSkyParalyzeTarget",    # Bounce                    # Not listed on PhoenixDex
#      "TwoTurnAttackInvulnerableInSkyTargetCannotAct",   # Sky Drop                  # Not listed on PhoenixDex
#      "AllBattlersLoseHalfHPUserSkipsNextTurn",          # Shadow Half               # Not listed on PhoenixDex
#      "TwoTurnAttackRaiseUserSpAtkSpDefSpd2",            # Geomancy                  # Not listed on PhoenixDex
    ]
  end

  def pbMoveFailed?(user, targets)
    if @moveBlacklist.include?(GameData::Move.get(@copied_move).function_code)
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectAgainstTarget(user, target)
    user.pbUseMoveSimple(target.lastRegularMoveUsed, target.index)
  end

  def pbShowAnimation(id, user, targets, hitNum = 0, showAnimation = true)
    # No animation
  end
end
#===============================================================================
# Inflicts a random non-volatile status on the target. (Pixie Dust)
#===============================================================================
class Battle::Move::RandomStatusTarget < Battle::Move
  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    case @battle.pbRandom(5)
    when 0 then target.pbBurn(user) if target.pbCanBurn?(user, false, self)
    when 1 then target.pbFreeze if target.pbCanFreeze?(user, false, self)
    when 2 then target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
    when 3 then target.pbPoison(user) if target.pbCanPoison?(user, false, self)
    when 4 then target.pbSleep if target.pbCanSleep?(user, false, self)
    end
  end
end
#==================================================================================
# For 5 rounds, surrounds the battle with a garden of Power Herbs. (Power Garden)
#==================================================================================
class Battle::Move::StartPowerGarden < Battle::Move
  def pbMoveFailed?(user, targets)
    if @battle.field.effects[PBEffects::GardenType] == "Power"
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    if @battle.field.effects[PBEffects::GardenCount] > 0
        #pbCommonAnimation("GardenWilt")
        @battle.pbDisplay(_INTL("The last garden wilted..."))
    end
    @battle.field.effects[PBEffects::GardenType] = "Power"
    @battle.field.effects[PBEffects::GardenCount] = 5
    @battle.pbDisplay(_INTL("A garden of Power Herbs bloomed around the battlefield!"))
  end

end
#===============================================================================
# Decreases the target's Special Defense by 1 stage,
# raises user's Special Attack by one stage. (Psych Out)
#===============================================================================
class Battle::Move::LowerTargetSpDefense1RaiseUserSpAttack1 < Battle::Move::TargetStatDownMove
  def initialize(battle, move)
    super
    @statDown = [:SPECIAL_DEFENSE, 1]
  end
end
#===============================================================================
# Target's Special Defense is used instead of its Defense for this move's
# calculations. (Radiant Claw)
#===============================================================================
class Battle::Move::UseTargetSpDefInsteadOfTargetDefense < Battle::Move
  def pbGetDefenseStats(user, target)
    return target.spdef, target.stages[:SPECIAL_DEFENSE] + 6
  end
end
#===============================================================================
# For 5 rounds, lowers power of all attacks against the user's side. (Rainbow Wall)
#===============================================================================
class Battle::Move::StartWeakenDamageAgainstUserSide < Battle::Move
  def canSnatch?; return true; end

  def pbMoveFailed?(user, targets)
    if user.pbOwnSide.effects[PBEffects::RainbowWall] > 0
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    user.pbOwnSide.effects[PBEffects::RainbowWall] = 5
    user.pbOwnSide.effects[PBEffects::RainbowWall] = 8 if user.hasActiveItem?(:LIGHTCLAY)
    @battle.pbDisplay(_INTL("{1} raised {2}'s defenses!", @name, user.pbTeam(true)))
  end
end
#===============================================================================
# Burns the target. May lower target's speed by one stage. (Rockflow)
#===============================================================================
class Battle::Move::BurnTargetLowerTargetSpeed1 < Battle::Move

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    chance = pbAdditionalEffectChance(user, target, 10)
    return if chance == 0
    if target.pbCanBurn?(user, false, self) && @battle.pbRandom(100) < chance
      target.pbBurn(user)
    end
    if target.pbCanLowerStatStage?(:SPEED, user, self) && @battle.pbRandom(100) < chance
      target.pbLowerStatStage(:SPEED, 1, user)
    end
  end
end
#===============================================================================
# Burns the target. Power doubles in a sandstorm. (Sandblast)
#===============================================================================
class Battle::Move::BurnTargetDoublePowerSandstorm < Battle::Move::BurnTarget
  def pbBaseDamage(baseDmg, user, target)
    baseDmg *= 2 if user.effectiveWeather == :Sandstorm
    return baseDmg
  end
end
#===============================================================================
# User copies the target's stat stages and lowers target's accuracy. (Snapshot)
#===============================================================================
class Battle::Move::UserStealTargetStatStagesLowersAccuracy < Battle::Move
#  def ignoresSubstitute?(user); return true; end

  def pbEffectAgainstTarget(user, target)
    GameData::Stat.each_battle do |s|
      if user.stages[s.id] > target.stages[s.id]
        user.statsLoweredThisRound = true
        user.statsDropped = true
      elsif user.stages[s.id] < target.stages[s.id]
        user.statsRaisedThisRound = true
      end
      user.stages[s.id] = target.stages[s.id]
    end
    if Settings::NEW_CRITICAL_HIT_RATE_MECHANICS
      user.effects[PBEffects::FocusEnergy] = target.effects[PBEffects::FocusEnergy]
      user.effects[PBEffects::LaserFocus]  = target.effects[PBEffects::LaserFocus]
    end
    target.pbResetStatStages
    if Settings::NEW_CRITICAL_HIT_RATE_MECHANICS
      target.effects[PBEffects::FocusEnergy] = 0
      target.effects[PBEffects::LaserFocus]  = 0
    end
    @battle.pbDisplay(_INTL("{1} took {2}'s stat changes!", user.pbThis, target.pbThis(true)))
    if target.pbCanLowerStatStage?(:ACCURACY, user, self)
        target.pbLowerStatStage(:ACCURACY, 1 user, self)
    end
  end
end
#===============================================================================
# Two turn attack. Skips first turn, attacks second turn. Paralyzes target.
# If user has Static ability, takes 1 turn instead. (Static Strike)
#===============================================================================
class Battle::Move::TwoTurnAttackOneTurnStaticParalyzeTarget < Battle::Move::TwoTurnMove
  def pbIsChargingTurn?(user)
    ret = super
    if !user.effects[PBEffects::TwoTurnAttack] &&
       user.hasActiveAbility?(:STATIC)
      @powerHerb = false
      @chargingTurn = true
      @damagingTurn = true
      return false
    end
    return ret
  end

  def pbChargingTurnMessage(user, targets)
    @battle.pbDisplay(_INTL("{1} built up static!", user.pbThis))
  end

  def pbEffectAgainstTarget(user, target)
    return if damagingMove?
    target.pbParalyze(user)
  end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    target.pbParalyze(user) if target.pbCanParalyze?(user, false, self)
  end

end
#===============================================================================
# In double/triple battles, the user and its allies gain 25% of their total HP.
# In single battles, the user gains 50% of its total HP. (Steam Bath)
#===============================================================================
class Battle::Move::HealUserAndAlliesQuarterOfTotalHPOrHealUserHalfTotalHP < Battle::Move
  def healingMove?; return true; end

  def pbMoveFailed?(user, targets)
    if @battle.allSameSideBattlers(user).none? { |b| b.canHeal? }
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbFailsAgainstTarget?(user, target, show_message)
    return !target.canHeal?
  end

  def pbEffectAgainstTarget(user, target)
    if @battle.pbSideBattlerCount(user) > 1
        target.pbRecoverHP(target.totalhp / 4)
    else
        target.pbRecoverHP(target.totalhp / 2)
    end
    @battle.pbDisplay(_INTL("{1}'s HP was restored.", target.pbThis))
  end
end
#===============================================================================
# User steals the target's item. If the user has an item, just removes the item.
# Items stolen from wild Pokémon are kept after the battle. (Sticky Fingers)
#===============================================================================
class Battle::Move::UserTakesOrTossesTargetItem < Battle::Move
  def pbEffectAfterAllHits(user, target)
    return if user.wild?   # Wild Pokémon can't thieve
    return if user.fainted?
    return if target.damageState.unaffected || target.damageState.substitute
    return if !target.item
    return if target.unlosableItem?(target.item)
    return if user.unlosableItem?(target.item)
    return if target.hasActiveAbility?(:STICKYHOLD) && !@battle.moldBreaker
    itemName = target.itemName
    if !user.item
        user.item = target.item
        @battle.pbDisplay(_INTL("{1} stole {2}'s {3}!", user.pbThis, target.pbThis(true), itemName))
    else
        @battle.pbDisplay(_INTL("{1} tossed {2}'s {3}!", user.pbThis, target.pbThis(true), itemName))
    end
    # Permanently steal the item from wild Pokémon
    if target.wild? && !user.initialItem && target.item == target.initialItem
      user.setInitialItem(target.item)
      target.pbRemoveItem
    else
      target.pbRemoveItem(false)
    end
    user.pbHeldItemTriggerCheck
  end
end
#===============================================================================
# Increases the user's Special Defense by 1 stage.
# Charges up user's next attack if it is Fire-type. (Stoke)
#===============================================================================
class Battle::Move::RaiseUserSpDef1PowerUpFireMove < Battle::Move::StatUpMove
  def initialize(battle, move)
    super
    @statUp = [:SPECIAL_DEFENSE, 1]
  end

  def pbEffectGeneral(user)
    user.effects[PBEffects::Stoke] = 2
    @battle.pbDisplay(_INTL("{1} began stoking its flames!", user.pbThis))
    super
  end
end
#===============================================================================
# In trainer battles, target switches out. Target and new opponent are both poisoned.
# In wild battles, makes target flee. If target is a higher level than the
# user, target is poisoned instead. (Viral Gale)
#===============================================================================
class Battle::Move::SwitchOutTargetStatusMovePoisonTarget < Battle::Move
  def ignoresSubstitute?(user); return true; end
  def canMagicCoat?;            return true; end

  def pbFailsAgainstTarget?(user, target, show_message)
    if target.hasActiveAbility?(:SUCTIONCUPS) && !@battle.moldBreaker
      target.pbPoison(user) if target.pbCanPoison?(user, false, self)
      if show_message
        @battle.pbShowAbilitySplash(target)
        if Battle::Scene::USE_ABILITY_SPLASH
          @battle.pbDisplay(_INTL("{1} anchors itself!", target.pbThis))
        else
          @battle.pbDisplay(_INTL("{1} anchors itself with {2}!", target.pbThis, target.abilityName))
        end
        @battle.pbHideAbilitySplash(target)
      end
      return true
    end
    if target.effects[PBEffects::Ingrain]
      target.pbPoison(user) if target.pbCanPoison?(user, false, self)
      @battle.pbDisplay(_INTL("{1} anchored itself with its roots!", target.pbThis)) if show_message
      return true
    end
    if !@battle.canRun || (@battle.wildBattle? && target.level > user.level)
      target.pbPoison(user) if target.pbCanPoison?(user, false, self)
      @battle.pbDisplay(_INTL("{1} remained in battle!", target.pbThis)) if show_message
      return true
    end
    if @battle.trainerBattle?
      canSwitch = false
      @battle.eachInTeamFromBattlerIndex(target.index) do |_pkmn, i|
        next if !@battle.pbCanSwitchLax?(target.index, i)
        canSwitch = true
        break
      end
      if !canSwitch
        target.pbPoison(user) if target.pbCanPoison?(user, false, self)
        @battle.pbDisplay(_INTL("{1} has no allies to take its place!"),target.pbThis) if show_message
        return true
      end
    end
    return false
  end

  def pbEffectGeneral(user)
    @battle.decision = 3 if @battle.wildBattle?   # Escaped from battle
  end

  def pbSwitchOutTargetEffect(user, targets, numHits, switched_battlers)
    return if @battle.wildBattle? || !switched_battlers.empty?
    return if user.fainted? || numHits == 0
    targets.each do |b|
      next if b.fainted? || b.damageState.unaffected
      b.pbPoison(user) if b.pbCanPoison?(user, false, self)
      next if b.effects[PBEffects::Ingrain]
      next if b.hasActiveAbility?(:SUCTIONCUPS) && !@battle.moldBreaker
      newPkmn = @battle.pbGetReplacementPokemonIndex(b.index, true)   # Random
      next if newPkmn < 0
      @battle.pbRecallAndReplace(b.index, newPkmn, true)
      @battle.pbDisplay(_INTL("{1} was dragged out!", b.pbThis))
      @battle.pbClearChoice(b.index)   # Replacement Pokémon does nothing this round
      @battle.pbOnBattlerEnteringBattle(b.index)
      switched_battlers.push(b.index)
      @battle.battlers[b.index].pbPoison(user) if b.pbCanPoison?(@battle.battlers[b.index], false, self)
      break
    end
  end
end
#===============================================================================
# Passes the user's non-volatile status onto the target. (Viral Strike)
#===============================================================================
class Battle::Move::PassUserStatusToTarget < Battle::Move
  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute || !user.pbHasAnyStatus?
    if target.pbCanInflictStatus?(user.status, user, false, self)
        target.pbInflictStatus(user.status, user.statusCount, false, user)
    end
  end
end
#===============================================================================
# If target is Water-type, raises target's Special Attack 2 stages.
# Otherwise, lowers target's Special Attack 2 stages. (Waterlog)
#===============================================================================
class Battle::Move::LowerTargetSpAtk2RaiseWater < Battle::Move
  def canMagicCoat?; return true; end

  def pbFailsAgainstTarget?(user, target, show_message)
    return false if damagingMove?
    if target.pbHasType?(:WATER)
        return !target.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self, show_message)
    else
        return !target.pbCanLowerStatStage?(:SPECIAL_ATTACK, user, self, show_message)
    end
  end

  def pbEffectAgainstTarget(user, target)
    return if damagingMove?
    if target.pbHasType?(:WATER)
        target.pbRaiseStatStage(:SPECIAL_ATTACK, 2, user)
    else
        target.pbLowerStatStage(:SPECIAL_ATTACK, 2, user)
    end
  end

  def pbAdditionalEffect(user, target)
    return if target.damageState.substitute
    if target.pbHasType?(:WATER)
        return if !target.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user, self)
        target.pbRaiseStatStage(:SPECIAL_ATTACK, 2, user)
    else
        return if !target.pbCanLowerStatStage?(:SPECIAL_ATTACK, user, self)
        target.pbLowerStatStage(:SPECIAL_ATTACK, 2, user)
    end
  end
end

#===============================================================================
# For 5 rounds, surrounds the battle with a garden of White Herbs. (White Garden)
#===============================================================================
class Battle::Move::StartWhiteGarden < Battle::Move
  def pbMoveFailed?(user, targets)
    if @battle.field.effects[PBEffects::GardenType] == "White"
      @battle.pbDisplay(_INTL("But it failed!"))
      return true
    end
    return false
  end

  def pbEffectGeneral(user)
    if @battle.field.effects[PBEffects::GardenCount] > 0
        #pbCommonAnimation("GardenWilt")
        @battle.pbDisplay(_INTL("The last garden wilted..."))
    end
    @battle.field.effects[PBEffects::GardenType] = "White"
    @battle.field.effects[PBEffects::GardenCount] = 5
    @battle.pbDisplay(_INTL("A garden of White Herbs bloomed around the battlefield!"))
  end

end
#===============================================================================
# Accuracy perfect when team has Tailwind. Hits targets in the sky. (Windstorm)
#===============================================================================
class Battle::Move::AlwaysHitsWithTailwindHitsTargetInSky < Battle::Move
  def hitsFlyingTargets?; return true; end

  def pbBaseAccuracy(user, target)
    return 0 if user.pbOwnSide.effects[PBEffects::Tailwind] > 0
    return super
  end
end