Yet more script rearranging

Data/Scripts/011_Battle/002_Move/001_PokeBattle_Move.rb

@@ -0,0 +1,141 @@
+class PokeBattle_Move
+  attr_reader   :battle
+  attr_reader   :realMove
+  attr_accessor :id
+  attr_reader   :name
+  attr_reader   :function
+  attr_reader   :baseDamage
+  attr_reader   :type
+  attr_reader   :category
+  attr_reader   :accuracy
+  attr_accessor :pp
+  attr_writer   :total_pp
+  attr_reader   :addlEffect
+  attr_reader   :target
+  attr_reader   :priority
+  attr_reader   :flags
+  attr_accessor :calcType
+  attr_accessor :powerBoost
+  attr_accessor :snatched
+
+  def to_int; return @id; end
+
+  #=============================================================================
+  # Creating a move
+  #=============================================================================
+  def initialize(battle, move)
+    @battle     = battle
+    @realMove   = move
+    @id         = move.id
+    @name       = move.name   # Get the move's name
+    # Get data on the move
+    @function   = move.function_code
+    @baseDamage = move.base_damage
+    @type       = move.type
+    @category   = move.category
+    @accuracy   = move.accuracy
+    @pp         = move.pp   # Can be changed with Mimic/Transform
+    @addlEffect = move.effect_chance
+    @target     = move.target
+    @priority   = move.priority
+    @flags      = move.flags
+    @calcType   = nil
+    @powerBoost = false   # For Aerilate, Pixilate, Refrigerate, Galvanize
+    @snatched   = false
+  end
+
+  # This is the code actually used to generate a PokeBattle_Move object. The
+  # object generated is a subclass of this one which depends on the move's
+  # function code (found in the script section PokeBattle_MoveEffect).
+  def PokeBattle_Move.from_pokemon_move(battle, move)
+    validate move => Pokemon::Move
+    moveFunction = move.function_code || "000"
+    className = sprintf("PokeBattle_Move_%s", moveFunction)
+    if Object.const_defined?(className)
+      return Object.const_get(className).new(battle, move)
+    end
+    return PokeBattle_UnimplementedMove.new(battle, move)
+  end
+
+  #=============================================================================
+  # About the move
+  #=============================================================================
+  def pbTarget(_user); return GameData::Target.get(@target); end
+
+  def total_pp
+    return @total_pp if @total_pp && @total_pp>0   # Usually undefined
+    return @realMove.total_pp if @realMove
+    return 0
+  end
+
+  # NOTE: This method is only ever called while using a move (and also by the
+  #       AI), so using @calcType here is acceptable.
+  def physicalMove?(thisType=nil)
+    return (@category==0) if Settings::MOVE_CATEGORY_PER_MOVE
+    thisType ||= @calcType
+    thisType ||= @type
+    return true if !thisType
+    return GameData::Type.get(thisType).physical?
+  end
+
+  # NOTE: This method is only ever called while using a move (and also by the
+  #       AI), so using @calcType here is acceptable.
+  def specialMove?(thisType=nil)
+    return (@category==1) if Settings::MOVE_CATEGORY_PER_MOVE
+    thisType ||= @calcType
+    thisType ||= @type
+    return false if !thisType
+    return GameData::Type.get(thisType).special?
+  end
+
+  def damagingMove?; return @category!=2; end
+  def statusMove?;   return @category==2; end
+
+  def usableWhenAsleep?;       return false; end
+  def unusableInGravity?;      return false; end
+  def healingMove?;            return false; end
+  def recoilMove?;             return false; end
+  def flinchingMove?;          return false; end
+  def callsAnotherMove?;       return false; end
+  # Whether the move can/will hit more than once in the same turn (including
+  # Beat Up which may instead hit just once). Not the same as pbNumHits>1.
+  def multiHitMove?;           return false; end
+  def chargingTurnMove?;       return false; end
+  def successCheckPerHit?;     return false; end
+  def hitsFlyingTargets?;      return false; end
+  def hitsDiggingTargets?;     return false; end
+  def hitsDivingTargets?;      return false; end
+  def ignoresReflect?;         return false; end   # For Brick Break
+  def cannotRedirect?;         return false; end   # For Future Sight/Doom Desire
+  def worksWithNoTargets?;     return false; end   # For Explosion
+  def damageReducedByBurn?;    return true;  end   # For Facade
+  def triggersHyperMode?;      return false; end
+
+  def contactMove?;       return @flags[/a/]; end
+  def canProtectAgainst?; return @flags[/b/]; end
+  def canMagicCoat?;      return @flags[/c/]; end
+  def canSnatch?;         return @flags[/d/]; end
+  def canMirrorMove?;     return @flags[/e/]; end
+  def canKingsRock?;      return @flags[/f/]; end
+  def thawsUser?;         return @flags[/g/]; end
+  def highCriticalRate?;  return @flags[/h/]; end
+  def bitingMove?;        return @flags[/i/]; end
+  def punchingMove?;      return @flags[/j/]; end
+  def soundMove?;         return @flags[/k/]; end
+  def powderMove?;        return @flags[/l/]; end
+  def pulseMove?;         return @flags[/m/]; end
+  def bombMove?;          return @flags[/n/]; end
+  def danceMove?;         return @flags[/o/]; end
+
+  # Causes perfect accuracy (param=1) and double damage (param=2).
+  def tramplesMinimize?(_param=1); return false; end
+  def nonLethal?(_user,_target); return false; end   # For False Swipe
+
+  def ignoresSubstitute?(user)   # user is the Pokémon using this move
+    if Settings::MECHANICS_GENERATION >= 6
+      return true if soundMove?
+      return true if user && user.hasActiveAbility?(:INFILTRATOR)
+    end
+    return false
+  end
+end

Data/Scripts/011_Battle/002_Move/002_Move_Usage.rb

@@ -0,0 +1,350 @@
+class PokeBattle_Move
+  #=============================================================================
+  # Effect methods per move usage
+  #=============================================================================
+  def pbCanChooseMove?(user,commandPhase,showMessages); return true; end   # For Belch
+  def pbDisplayChargeMessage(user); end   # For Focus Punch/shell Trap/Beak Blast
+  def pbOnStartUse(user,targets); end
+  def pbAddTarget(targets,user); end      # For Counter, etc. and Bide
+
+  # Reset move usage counters (child classes can increment them).
+  def pbChangeUsageCounters(user,specialUsage)
+    user.effects[PBEffects::FuryCutter]   = 0
+    user.effects[PBEffects::ParentalBond] = 0
+    user.effects[PBEffects::ProtectRate]  = 1
+    @battle.field.effects[PBEffects::FusionBolt]  = false
+    @battle.field.effects[PBEffects::FusionFlare] = false
+  end
+
+  def pbDisplayUseMessage(user)
+    @battle.pbDisplayBrief(_INTL("{1} used {2}!",user.pbThis,@name))
+  end
+
+  def pbMissMessage(user,target); return false; end
+
+  #=============================================================================
+  #
+  #=============================================================================
+  # Whether the move is currently in the "charging" turn of a two turn attack.
+  # Is false if Power Herb or another effect lets a two turn move charge and
+  # attack in the same turn.
+  # user.effects[PBEffects::TwoTurnAttack] is set to the move's ID during the
+  # charging turn, and is nil during the attack turn.
+  def pbIsChargingTurn?(user); return false; end
+  def pbDamagingMove?; return damagingMove?; end
+
+  def pbContactMove?(user)
+    return false if user.hasActiveAbility?(:LONGREACH)
+    return contactMove?
+  end
+
+  # The maximum number of hits in a round this move will actually perform. This
+  # can be 1 for Beat Up, and can be 2 for any moves affected by Parental Bond.
+  def pbNumHits(user,targets)
+    if user.hasActiveAbility?(:PARENTALBOND) && pbDamagingMove? &&
+       !chargingTurnMove? && targets.length==1
+      # Record that Parental Bond applies, to weaken the second attack
+      user.effects[PBEffects::ParentalBond] = 3
+      return 2
+    end
+    return 1
+  end
+
+  #=============================================================================
+  # Effect methods per hit
+  #=============================================================================
+  def pbOverrideSuccessCheckPerHit(user,target); return false; end
+  def pbCrashDamage(user); end
+  def pbInitialEffect(user,targets,hitNum); end
+
+  def pbShowAnimation(id,user,targets,hitNum=0,showAnimation=true)
+    return if !showAnimation
+    if user.effects[PBEffects::ParentalBond]==1
+      @battle.pbCommonAnimation("ParentalBond",user,targets)
+    else
+      @battle.pbAnimation(id,user,targets,hitNum)
+    end
+  end
+
+  def pbSelfKO(user); end
+  def pbEffectWhenDealingDamage(user,target); end
+  def pbEffectAgainstTarget(user,target); end
+  def pbEffectGeneral(user); end
+  def pbAdditionalEffect(user,target); end
+  def pbEffectAfterAllHits(user,target); end   # Move effects that occur after all hits
+  def pbSwitchOutTargetsEffect(user,targets,numHits,switchedBattlers); end
+  def pbEndOfMoveUsageEffect(user,targets,numHits,switchedBattlers); end
+
+  #=============================================================================
+  # Check if target is immune to the move because of its ability
+  #=============================================================================
+  def pbImmunityByAbility(user,target)
+    return false if @battle.moldBreaker
+    ret = false
+    if target.abilityActive?
+      ret = BattleHandlers.triggerMoveImmunityTargetAbility(target.ability,
+         user,target,self,@calcType,@battle)
+    end
+    return ret
+  end
+
+  #=============================================================================
+  # Move failure checks
+  #=============================================================================
+  # Check whether the move fails completely due to move-specific requirements.
+  def pbMoveFailed?(user,targets); return false; end
+  # Checks whether the move will be ineffective against the target.
+  def pbFailsAgainstTarget?(user,target); return false; end
+
+  def pbMoveFailedLastInRound?(user)
+    unmoved = false
+    @battle.eachBattler do |b|
+      next if b.index==user.index
+      next if @battle.choices[b.index][0]!=:UseMove && @battle.choices[b.index][0]!=:Shift
+      next if b.movedThisRound?
+      unmoved = true
+      break
+    end
+    if !unmoved
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    return false
+  end
+
+  def pbMoveFailedTargetAlreadyMoved?(target)
+    if (@battle.choices[target.index][0]!=:UseMove &&
+       @battle.choices[target.index][0]!=:Shift) || target.movedThisRound?
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    return false
+  end
+
+  def pbMoveFailedAromaVeil?(user,target,showMessage=true)
+    return false if @battle.moldBreaker
+    if target.hasActiveAbility?(:AROMAVEIL)
+      if showMessage
+        @battle.pbShowAbilitySplash(target)
+        if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
+          @battle.pbDisplay(_INTL("{1} is unaffected!",target.pbThis))
+        else
+          @battle.pbDisplay(_INTL("{1} is unaffected because of its {2}!",
+            target.pbThis,target.abilityName))
+        end
+        @battle.pbHideAbilitySplash(target)
+      end
+      return true
+    end
+    target.eachAlly do |b|
+      next if !b.hasActiveAbility?(:AROMAVEIL)
+      if showMessage
+        @battle.pbShowAbilitySplash(target)
+        if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
+          @battle.pbDisplay(_INTL("{1} is unaffected!",target.pbThis))
+        else
+          @battle.pbDisplay(_INTL("{1} is unaffected because of {2}'s {3}!",
+            target.pbThis,b.pbThis(true),b.abilityName))
+        end
+        @battle.pbHideAbilitySplash(target)
+      end
+      return true
+    end
+    return false
+  end
+
+  #=============================================================================
+  # Weaken the damage dealt (doesn't actually change a battler's HP)
+  #=============================================================================
+  def pbCheckDamageAbsorption(user,target)
+    # Substitute will take the damage
+    if target.effects[PBEffects::Substitute]>0 && !ignoresSubstitute?(user) &&
+       (!user || user.index!=target.index)
+      target.damageState.substitute = true
+      return
+    end
+    # Disguise will take the damage
+    if !@battle.moldBreaker && target.isSpecies?(:MIMIKYU) &&
+       target.form==0 && target.ability == :DISGUISE
+      target.damageState.disguise = true
+      return
+    end
+  end
+
+  def pbReduceDamage(user,target)
+    damage = target.damageState.calcDamage
+    # Substitute takes the damage
+    if target.damageState.substitute
+      damage = target.effects[PBEffects::Substitute] if damage>target.effects[PBEffects::Substitute]
+      target.damageState.hpLost       = damage
+      target.damageState.totalHPLost += damage
+      return
+    end
+    # Disguise takes the damage
+    return if target.damageState.disguise
+    # Target takes the damage
+    if damage>=target.hp
+      damage = target.hp
+      # Survive a lethal hit with 1 HP effects
+      if nonLethal?(user,target)
+        damage -= 1
+      elsif target.effects[PBEffects::Endure]
+        target.damageState.endured = true
+        damage -= 1
+      elsif damage==target.totalhp
+        if target.hasActiveAbility?(:STURDY) && !@battle.moldBreaker
+          target.damageState.sturdy = true
+          damage -= 1
+        elsif target.hasActiveItem?(:FOCUSSASH) && target.hp==target.totalhp
+          target.damageState.focusSash = true
+          damage -= 1
+        elsif target.hasActiveItem?(:FOCUSBAND) && @battle.pbRandom(100)<10
+          target.damageState.focusBand = true
+          damage -= 1
+        end
+      end
+    end
+    damage = 0 if damage<0
+    target.damageState.hpLost       = damage
+    target.damageState.totalHPLost += damage
+  end
+
+  #=============================================================================
+  # Change the target's HP by the amount calculated above
+  #=============================================================================
+  def pbInflictHPDamage(target)
+    if target.damageState.substitute
+      target.effects[PBEffects::Substitute] -= target.damageState.hpLost
+    else
+      target.hp -= target.damageState.hpLost
+    end
+  end
+
+  #=============================================================================
+  # Animate the damage dealt, including lowering the HP
+  #=============================================================================
+  # Animate being damaged and losing HP (by a move)
+  def pbAnimateHitAndHPLost(user,targets)
+    # Animate allies first, then foes
+    animArray = []
+    for side in 0...2   # side here means "allies first, then foes"
+      targets.each do |b|
+        next if b.damageState.unaffected || b.damageState.hpLost==0
+        next if (side==0 && b.opposes?(user)) || (side==1 && !b.opposes?(user))
+        oldHP = b.hp+b.damageState.hpLost
+        PBDebug.log("[Move damage] #{b.pbThis} lost #{b.damageState.hpLost} HP (#{oldHP}=>#{b.hp})")
+        effectiveness = 0
+        if Effectiveness.resistant?(b.damageState.typeMod);          effectiveness = 1
+        elsif Effectiveness.super_effective?(b.damageState.typeMod); effectiveness = 2
+        end
+        animArray.push([b,oldHP,effectiveness])
+      end
+      if animArray.length>0
+        @battle.scene.pbHitAndHPLossAnimation(animArray)
+        animArray.clear
+      end
+    end
+  end
+
+  #=============================================================================
+  # Messages upon being hit
+  #=============================================================================
+  def pbEffectivenessMessage(user,target,numTargets=1)
+    return if target.damageState.disguise
+    if Effectiveness.super_effective?(target.damageState.typeMod)
+      if numTargets>1
+        @battle.pbDisplay(_INTL("It's super effective on {1}!",target.pbThis(true)))
+      else
+        @battle.pbDisplay(_INTL("It's super effective!"))
+      end
+    elsif Effectiveness.not_very_effective?(target.damageState.typeMod)
+      if numTargets>1
+        @battle.pbDisplay(_INTL("It's not very effective on {1}...",target.pbThis(true)))
+      else
+        @battle.pbDisplay(_INTL("It's not very effective..."))
+      end
+    end
+  end
+
+  def pbHitEffectivenessMessages(user,target,numTargets=1)
+    return if target.damageState.disguise
+    if target.damageState.substitute
+      @battle.pbDisplay(_INTL("The substitute took damage for {1}!",target.pbThis(true)))
+    end
+    if target.damageState.critical
+      if numTargets>1
+        @battle.pbDisplay(_INTL("A critical hit on {1}!",target.pbThis(true)))
+      else
+        @battle.pbDisplay(_INTL("A critical hit!"))
+      end
+    end
+    # Effectiveness message, for moves with 1 hit
+    if !multiHitMove? && user.effects[PBEffects::ParentalBond]==0
+      pbEffectivenessMessage(user,target,numTargets)
+    end
+    if target.damageState.substitute && target.effects[PBEffects::Substitute]==0
+      target.effects[PBEffects::Substitute] = 0
+      @battle.pbDisplay(_INTL("{1}'s substitute faded!",target.pbThis))
+    end
+  end
+
+  def pbEndureKOMessage(target)
+    if target.damageState.disguise
+      @battle.pbShowAbilitySplash(target)
+      if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
+        @battle.pbDisplay(_INTL("Its disguise served it as a decoy!"))
+      else
+        @battle.pbDisplay(_INTL("{1}'s disguise served it as a decoy!",target.pbThis))
+      end
+      @battle.pbHideAbilitySplash(target)
+      target.pbChangeForm(1,_INTL("{1}'s disguise was busted!",target.pbThis))
+    elsif target.damageState.endured
+      @battle.pbDisplay(_INTL("{1} endured the hit!",target.pbThis))
+    elsif target.damageState.sturdy
+      @battle.pbShowAbilitySplash(target)
+      if PokeBattle_SceneConstants::USE_ABILITY_SPLASH
+        @battle.pbDisplay(_INTL("{1} endured the hit!",target.pbThis))
+      else
+        @battle.pbDisplay(_INTL("{1} hung on with Sturdy!",target.pbThis))
+      end
+      @battle.pbHideAbilitySplash(target)
+    elsif target.damageState.focusSash
+      @battle.pbCommonAnimation("UseItem",target)
+      @battle.pbDisplay(_INTL("{1} hung on using its Focus Sash!",target.pbThis))
+      target.pbConsumeItem
+    elsif target.damageState.focusBand
+      @battle.pbCommonAnimation("UseItem",target)
+      @battle.pbDisplay(_INTL("{1} hung on using its Focus Band!",target.pbThis))
+    end
+  end
+
+  # Used by Counter/Mirror Coat/Metal Burst/Revenge/Focus Punch/Bide/Assurance.
+  def pbRecordDamageLost(user,target)
+    damage = target.damageState.hpLost
+    # NOTE: In Gen 3 where a move's category depends on its type, Hidden Power
+    #       is for some reason countered by Counter rather than Mirror Coat,
+    #       regardless of its calculated type. Hence the following two lines of
+    #       code.
+    moveType = nil
+    moveType = :NORMAL if @function=="090"   # Hidden Power
+    if physicalMove?(moveType)
+      target.effects[PBEffects::Counter]       = damage
+      target.effects[PBEffects::CounterTarget] = user.index
+    elsif specialMove?(moveType)
+      target.effects[PBEffects::MirrorCoat]       = damage
+      target.effects[PBEffects::MirrorCoatTarget] = user.index
+    end
+    if target.effects[PBEffects::Bide]>0
+      target.effects[PBEffects::BideDamage] += damage
+      target.effects[PBEffects::BideTarget] = user.index
+    end
+    target.damageState.fainted = true if target.fainted?
+    target.lastHPLost = damage             # For Focus Punch
+    target.tookDamage = true if damage>0   # For Assurance
+    target.lastAttacker.push(user.index)   # For Revenge
+    if target.opposes?(user)
+      target.lastHPLostFromFoe = damage              # For Metal Burst
+      target.lastFoeAttacker.push(user.index)        # For Metal Burst
+    end
+  end
+end

Data/Scripts/011_Battle/002_Move/003_Move_Usage_Calculations.rb

@@ -0,0 +1,491 @@
+class PokeBattle_Move
+  #=============================================================================
+  # Move's type calculation
+  #=============================================================================
+  def pbBaseType(user)
+    ret = @type
+    if ret && user.abilityActive?
+      ret = BattleHandlers.triggerMoveBaseTypeModifierAbility(user.ability,user,self,ret)
+    end
+    return ret
+  end
+
+  def pbCalcType(user)
+    @powerBoost = false
+    ret = pbBaseType(user)
+    if ret && GameData::Type.exists?(:ELECTRIC)
+      if @battle.field.effects[PBEffects::IonDeluge] && ret == :NORMAL
+        ret = :ELECTRIC
+        @powerBoost = false
+      end
+      if user.effects[PBEffects::Electrify]
+        ret = :ELECTRIC
+        @powerBoost = false
+      end
+    end
+    return ret
+  end
+
+  #=============================================================================
+  # Type effectiveness calculation
+  #=============================================================================
+  def pbCalcTypeModSingle(moveType,defType,user,target)
+    ret = Effectiveness.calculate_one(moveType, defType)
+    # Ring Target
+    if target.hasActiveItem?(:RINGTARGET)
+      ret = Effectiveness::NORMAL_EFFECTIVE_ONE if Effectiveness.ineffective_type?(moveType, defType)
+    end
+    # Foresight
+    if user.hasActiveAbility?(:SCRAPPY) || target.effects[PBEffects::Foresight]
+      ret = Effectiveness::NORMAL_EFFECTIVE_ONE if defType == :GHOST &&
+                                                   Effectiveness.ineffective_type?(moveType, defType)
+    end
+    # Miracle Eye
+    if target.effects[PBEffects::MiracleEye]
+      ret = Effectiveness::NORMAL_EFFECTIVE_ONE if defType == :DARK &&
+                                                   Effectiveness.ineffective_type?(moveType, defType)
+    end
+    # Delta Stream's weather
+    if @battle.pbWeather == :StrongWinds
+      ret = Effectiveness::NORMAL_EFFECTIVE_ONE if defType == :FLYING &&
+                                                   Effectiveness.super_effective_type?(moveType, defType)
+    end
+    # Grounded Flying-type Pokémon become susceptible to Ground moves
+    if !target.airborne?
+      ret = Effectiveness::NORMAL_EFFECTIVE_ONE if defType == :FLYING && moveType == :GROUND
+    end
+    return ret
+  end
+
+  def pbCalcTypeMod(moveType,user,target)
+    return Effectiveness::NORMAL_EFFECTIVE if !moveType
+    return Effectiveness::NORMAL_EFFECTIVE if moveType == :GROUND &&
+       target.pbHasType?(:FLYING) && target.hasActiveItem?(:IRONBALL)
+    # Determine types
+    tTypes = target.pbTypes(true)
+    # Get effectivenesses
+    typeMods = [Effectiveness::NORMAL_EFFECTIVE_ONE] * 3   # 3 types max
+    if moveType == :SHADOW
+      if target.shadowPokemon?
+        typeMods[0] = Effectiveness::NOT_VERY_EFFECTIVE_ONE
+      else
+        typeMods[0] = Effectiveness::SUPER_EFFECTIVE_ONE
+      end
+    else
+      tTypes.each_with_index do |type,i|
+        typeMods[i] = pbCalcTypeModSingle(moveType,type,user,target)
+      end
+    end
+    # Multiply all effectivenesses together
+    ret = 1
+    typeMods.each { |m| ret *= m }
+    return ret
+  end
+
+  #=============================================================================
+  # Accuracy check
+  #=============================================================================
+  def pbBaseAccuracy(user,target); return @accuracy; end
+
+  # Accuracy calculations for one-hit KO moves and "always hit" moves are
+  # handled elsewhere.
+  def pbAccuracyCheck(user,target)
+    # "Always hit" effects and "always hit" accuracy
+    return true if target.effects[PBEffects::Telekinesis]>0
+    return true if target.effects[PBEffects::Minimize] && tramplesMinimize?(1)
+    baseAcc = pbBaseAccuracy(user,target)
+    return true if baseAcc==0
+    # Calculate all multiplier effects
+    modifiers = {}
+    modifiers[:base_accuracy]  = baseAcc
+    modifiers[:accuracy_stage] = user.stages[:ACCURACY]
+    modifiers[:evasion_stage]  = target.stages[:EVASION]
+    modifiers[:accuracy_multiplier] = 1.0
+    modifiers[:evasion_multiplier]  = 1.0
+    pbCalcAccuracyModifiers(user,target,modifiers)
+    # Check if move can't miss
+    return true if modifiers[:base_accuracy] == 0
+    # Calculation
+    accStage = [[modifiers[:accuracy_stage], -6].max, 6].min + 6
+    evaStage = [[modifiers[:evasion_stage], -6].max, 6].min + 6
+    stageMul = [3,3,3,3,3,3, 3, 4,5,6,7,8,9]
+    stageDiv = [9,8,7,6,5,4, 3, 3,3,3,3,3,3]
+    accuracy = 100.0 * stageMul[accStage] / stageDiv[accStage]
+    evasion  = 100.0 * stageMul[evaStage] / stageDiv[evaStage]
+    accuracy = (accuracy * modifiers[:accuracy_multiplier]).round
+    evasion  = (evasion  * modifiers[:evasion_multiplier]).round
+    evasion = 1 if evasion < 1
+    # Calculation
+    return @battle.pbRandom(100) < modifiers[:base_accuracy] * accuracy / evasion
+  end
+
+  def pbCalcAccuracyModifiers(user,target,modifiers)
+    # Ability effects that alter accuracy calculation
+    if user.abilityActive?
+      BattleHandlers.triggerAccuracyCalcUserAbility(user.ability,
+         modifiers,user,target,self,@calcType)
+    end
+    user.eachAlly do |b|
+      next if !b.abilityActive?
+      BattleHandlers.triggerAccuracyCalcUserAllyAbility(b.ability,
+         modifiers,user,target,self,@calcType)
+    end
+    if target.abilityActive? && !@battle.moldBreaker
+      BattleHandlers.triggerAccuracyCalcTargetAbility(target.ability,
+         modifiers,user,target,self,@calcType)
+    end
+    # Item effects that alter accuracy calculation
+    if user.itemActive?
+      BattleHandlers.triggerAccuracyCalcUserItem(user.item,
+         modifiers,user,target,self,@calcType)
+    end
+    if target.itemActive?
+      BattleHandlers.triggerAccuracyCalcTargetItem(target.item,
+         modifiers,user,target,self,@calcType)
+    end
+    # Other effects, inc. ones that set accuracy_multiplier or evasion_stage to
+    # specific values
+    if @battle.field.effects[PBEffects::Gravity] > 0
+      modifiers[:accuracy_multiplier] *= 5 / 3.0
+    end
+    if user.effects[PBEffects::MicleBerry]
+      user.effects[PBEffects::MicleBerry] = false
+      modifiers[:accuracy_multiplier] *= 1.2
+    end
+    modifiers[:evasion_stage] = 0 if target.effects[PBEffects::Foresight] && modifiers[:evasion_stage] > 0
+    modifiers[:evasion_stage] = 0 if target.effects[PBEffects::MiracleEye] && modifiers[:evasion_stage] > 0
+  end
+
+  #=============================================================================
+  # Critical hit check
+  #=============================================================================
+  # Return values:
+  #   -1: Never a critical hit.
+  #    0: Calculate normally.
+  #    1: Always a critical hit.
+  def pbCritialOverride(user,target); return 0; end
+
+  # Returns whether the move will be a critical hit.
+  def pbIsCritical?(user,target)
+    return false if target.pbOwnSide.effects[PBEffects::LuckyChant]>0
+    # Set up the critical hit ratios
+    ratios = (Settings::NEW_CRITICAL_HIT_RATE_MECHANICS) ? [24,8,2,1] : [16,8,4,3,2]
+    c = 0
+    # Ability effects that alter critical hit rate
+    if c>=0 && user.abilityActive?
+      c = BattleHandlers.triggerCriticalCalcUserAbility(user.ability,user,target,c)
+    end
+    if c>=0 && target.abilityActive? && !@battle.moldBreaker
+      c = BattleHandlers.triggerCriticalCalcTargetAbility(target.ability,user,target,c)
+    end
+    # Item effects that alter critical hit rate
+    if c>=0 && user.itemActive?
+      c = BattleHandlers.triggerCriticalCalcUserItem(user.item,user,target,c)
+    end
+    if c>=0 && target.itemActive?
+      c = BattleHandlers.triggerCriticalCalcTargetItem(target.item,user,target,c)
+    end
+    return false if c<0
+    # Move-specific "always/never a critical hit" effects
+    case pbCritialOverride(user,target)
+    when 1  then return true
+    when -1 then return false
+    end
+    # Other effects
+    return true if c>50   # Merciless
+    return true if user.effects[PBEffects::LaserFocus]>0
+    c += 1 if highCriticalRate?
+    c += user.effects[PBEffects::FocusEnergy]
+    c += 1 if user.inHyperMode? && @type == :SHADOW
+    c = ratios.length-1 if c>=ratios.length
+    # Calculation
+    return @battle.pbRandom(ratios[c])==0
+  end
+
+  #=============================================================================
+  # Damage calculation
+  #=============================================================================
+  def pbBaseDamage(baseDmg,user,target);              return baseDmg;    end
+  def pbBaseDamageMultiplier(damageMult,user,target); return damageMult; end
+  def pbModifyDamage(damageMult,user,target);         return damageMult; end
+
+  def pbGetAttackStats(user,target)
+    if specialMove?
+      return user.spatk, user.stages[:SPECIAL_ATTACK]+6
+    end
+    return user.attack, user.stages[:ATTACK]+6
+  end
+
+  def pbGetDefenseStats(user,target)
+    if specialMove?
+      return target.spdef, target.stages[:SPECIAL_DEFENSE]+6
+    end
+    return target.defense, target.stages[:DEFENSE]+6
+  end
+
+  def pbCalcDamage(user,target,numTargets=1)
+    return if statusMove?
+    if target.damageState.disguise
+      target.damageState.calcDamage = 1
+      return
+    end
+    stageMul = [2,2,2,2,2,2, 2, 3,4,5,6,7,8]
+    stageDiv = [8,7,6,5,4,3, 2, 2,2,2,2,2,2]
+    # Get the move's type
+    type = @calcType   # nil is treated as physical
+    # Calculate whether this hit deals critical damage
+    target.damageState.critical = pbIsCritical?(user,target)
+    # Calcuate base power of move
+    baseDmg = pbBaseDamage(@baseDamage,user,target)
+    # Calculate user's attack stat
+    atk, atkStage = pbGetAttackStats(user,target)
+    if !target.hasActiveAbility?(:UNAWARE) || @battle.moldBreaker
+      atkStage = 6 if target.damageState.critical && atkStage<6
+      atk = (atk.to_f*stageMul[atkStage]/stageDiv[atkStage]).floor
+    end
+    # Calculate target's defense stat
+    defense, defStage = pbGetDefenseStats(user,target)
+    if !user.hasActiveAbility?(:UNAWARE)
+      defStage = 6 if target.damageState.critical && defStage>6
+      defense = (defense.to_f*stageMul[defStage]/stageDiv[defStage]).floor
+    end
+    # Calculate all multiplier effects
+    multipliers = {
+      :base_damage_multiplier  => 1.0,
+      :attack_multiplier       => 1.0,
+      :defense_multiplier      => 1.0,
+      :final_damage_multiplier => 1.0
+    }
+    pbCalcDamageMultipliers(user,target,numTargets,type,baseDmg,multipliers)
+    # Main damage calculation
+    baseDmg = [(baseDmg * multipliers[:base_damage_multiplier]).round, 1].max
+    atk     = [(atk     * multipliers[:attack_multiplier]).round, 1].max
+    defense = [(defense * multipliers[:defense_multiplier]).round, 1].max
+    damage  = (((2.0 * user.level / 5 + 2).floor * baseDmg * atk / defense).floor / 50).floor + 2
+    damage  = [(damage  * multipliers[:final_damage_multiplier]).round, 1].max
+    target.damageState.calcDamage = damage
+  end
+
+  def pbCalcDamageMultipliers(user,target,numTargets,type,baseDmg,multipliers)
+    # Global abilities
+    if (@battle.pbCheckGlobalAbility(:DARKAURA) && type == :DARK) ||
+       (@battle.pbCheckGlobalAbility(:FAIRYAURA) && type == :FAIRY)
+      if @battle.pbCheckGlobalAbility(:AURABREAK)
+        multipliers[:base_damage_multiplier] *= 2 / 3.0
+      else
+        multipliers[:base_damage_multiplier] *= 4 / 3.0
+      end
+    end
+    # Ability effects that alter damage
+    if user.abilityActive?
+      BattleHandlers.triggerDamageCalcUserAbility(user.ability,
+         user,target,self,multipliers,baseDmg,type)
+    end
+    if !@battle.moldBreaker
+      # NOTE: It's odd that the user's Mold Breaker prevents its partner's
+      #       beneficial abilities (i.e. Flower Gift boosting Atk), but that's
+      #       how it works.
+      user.eachAlly do |b|
+        next if !b.abilityActive?
+        BattleHandlers.triggerDamageCalcUserAllyAbility(b.ability,
+           user,target,self,multipliers,baseDmg,type)
+      end
+      if target.abilityActive?
+        BattleHandlers.triggerDamageCalcTargetAbility(target.ability,
+           user,target,self,multipliers,baseDmg,type) if !@battle.moldBreaker
+        BattleHandlers.triggerDamageCalcTargetAbilityNonIgnorable(target.ability,
+           user,target,self,multipliers,baseDmg,type)
+      end
+      target.eachAlly do |b|
+        next if !b.abilityActive?
+        BattleHandlers.triggerDamageCalcTargetAllyAbility(b.ability,
+           user,target,self,multipliers,baseDmg,type)
+      end
+    end
+    # Item effects that alter damage
+    if user.itemActive?
+      BattleHandlers.triggerDamageCalcUserItem(user.item,
+         user,target,self,multipliers,baseDmg,type)
+    end
+    if target.itemActive?
+      BattleHandlers.triggerDamageCalcTargetItem(target.item,
+         user,target,self,multipliers,baseDmg,type)
+    end
+    # Parental Bond's second attack
+    if user.effects[PBEffects::ParentalBond]==1
+      multipliers[:base_damage_multiplier] /= 4
+    end
+    # Other
+    if user.effects[PBEffects::MeFirst]
+      multipliers[:base_damage_multiplier] *= 1.5
+    end
+    if user.effects[PBEffects::HelpingHand] && !self.is_a?(PokeBattle_Confusion)
+      multipliers[:base_damage_multiplier] *= 1.5
+    end
+    if user.effects[PBEffects::Charge]>0 && type == :ELECTRIC
+      multipliers[:base_damage_multiplier] *= 2
+    end
+    # Mud Sport
+    if type == :ELECTRIC
+      @battle.eachBattler do |b|
+        next if !b.effects[PBEffects::MudSport]
+        multipliers[:base_damage_multiplier] /= 3
+        break
+      end
+      if @battle.field.effects[PBEffects::MudSportField]>0
+        multipliers[:base_damage_multiplier] /= 3
+      end
+    end
+    # Water Sport
+    if type == :FIRE
+      @battle.eachBattler do |b|
+        next if !b.effects[PBEffects::WaterSport]
+        multipliers[:base_damage_multiplier] /= 3
+        break
+      end
+      if @battle.field.effects[PBEffects::WaterSportField]>0
+        multipliers[:base_damage_multiplier] /= 3
+      end
+    end
+    # Terrain moves
+    case @battle.field.terrain
+    when :Electric
+      multipliers[:base_damage_multiplier] *= 1.5 if type == :ELECTRIC && user.affectedByTerrain?
+    when :Grassy
+      multipliers[:base_damage_multiplier] *= 1.5 if type == :GRASS && user.affectedByTerrain?
+    when :Psychic
+      multipliers[:base_damage_multiplier] *= 1.5 if type == :PSYCHIC && user.affectedByTerrain?
+    when :Misty
+      multipliers[:base_damage_multiplier] /= 2 if type == :DRAGON && target.affectedByTerrain?
+    end
+    # Badge multipliers
+    if @battle.internalBattle
+      if user.pbOwnedByPlayer?
+        if physicalMove? && @battle.pbPlayer.badge_count >= Settings::NUM_BADGES_BOOST_ATTACK
+          multipliers[:attack_multiplier] *= 1.1
+        elsif specialMove? && @battle.pbPlayer.badge_count >= Settings::NUM_BADGES_BOOST_SPATK
+          multipliers[:attack_multiplier] *= 1.1
+        end
+      end
+      if target.pbOwnedByPlayer?
+        if physicalMove? && @battle.pbPlayer.badge_count >= Settings::NUM_BADGES_BOOST_DEFENSE
+          multipliers[:defense_multiplier] *= 1.1
+        elsif specialMove? && @battle.pbPlayer.badge_count >= Settings::NUM_BADGES_BOOST_SPDEF
+          multipliers[:defense_multiplier] *= 1.1
+        end
+      end
+    end
+    # Multi-targeting attacks
+    if numTargets>1
+      multipliers[:final_damage_multiplier] *= 0.75
+    end
+    # Weather
+    case @battle.pbWeather
+    when :Sun, :HarshSun
+      if type == :FIRE
+        multipliers[:final_damage_multiplier] *= 1.5
+      elsif type == :WATER
+        multipliers[:final_damage_multiplier] /= 2
+      end
+    when :Rain, :HeavyRain
+      if type == :FIRE
+        multipliers[:final_damage_multiplier] /= 2
+      elsif type == :WATER
+        multipliers[:final_damage_multiplier] *= 1.5
+      end
+    when :Sandstorm
+      if target.pbHasType?(:ROCK) && specialMove? && @function != "122"   # Psyshock
+        multipliers[:defense_multiplier] *= 1.5
+      end
+    end
+    # Critical hits
+    if target.damageState.critical
+      if Settings::NEW_CRITICAL_HIT_RATE_MECHANICS
+        multipliers[:final_damage_multiplier] *= 1.5
+      else
+        multipliers[:final_damage_multiplier] *= 2
+      end
+    end
+    # Random variance
+    if !self.is_a?(PokeBattle_Confusion)
+      random = 85+@battle.pbRandom(16)
+      multipliers[:final_damage_multiplier] *= random / 100.0
+    end
+    # STAB
+    if type && user.pbHasType?(type)
+      if user.hasActiveAbility?(:ADAPTABILITY)
+        multipliers[:final_damage_multiplier] *= 2
+      else
+        multipliers[:final_damage_multiplier] *= 1.5
+      end
+    end
+    # Type effectiveness
+    multipliers[:final_damage_multiplier] *= target.damageState.typeMod.to_f / Effectiveness::NORMAL_EFFECTIVE
+    # Burn
+    if user.status == :BURN && physicalMove? && damageReducedByBurn? &&
+       !user.hasActiveAbility?(:GUTS)
+      multipliers[:final_damage_multiplier] /= 2
+    end
+    # Aurora Veil, Reflect, Light Screen
+    if !ignoresReflect? && !target.damageState.critical &&
+       !user.hasActiveAbility?(:INFILTRATOR)
+      if target.pbOwnSide.effects[PBEffects::AuroraVeil] > 0
+        if @battle.pbSideBattlerCount(target)>1
+          multipliers[:final_damage_multiplier] *= 2 / 3.0
+        else
+          multipliers[:final_damage_multiplier] /= 2
+        end
+      elsif target.pbOwnSide.effects[PBEffects::Reflect] > 0 && physicalMove?
+        if @battle.pbSideBattlerCount(target)>1
+          multipliers[:final_damage_multiplier] *= 2 / 3.0
+        else
+          multipliers[:final_damage_multiplier] /= 2
+        end
+      elsif target.pbOwnSide.effects[PBEffects::LightScreen] > 0 && specialMove?
+        if @battle.pbSideBattlerCount(target) > 1
+          multipliers[:final_damage_multiplier] *= 2 / 3.0
+        else
+          multipliers[:final_damage_multiplier] /= 2
+        end
+      end
+    end
+    # Minimize
+    if target.effects[PBEffects::Minimize] && tramplesMinimize?(2)
+      multipliers[:final_damage_multiplier] *= 2
+    end
+    # Move-specific base damage modifiers
+    multipliers[:base_damage_multiplier] = pbBaseDamageMultiplier(multipliers[:base_damage_multiplier], user, target)
+    # Move-specific final damage modifiers
+    multipliers[:final_damage_multiplier] = pbModifyDamage(multipliers[:final_damage_multiplier], user, target)
+  end
+
+  #=============================================================================
+  # Additional effect chance
+  #=============================================================================
+  def pbAdditionalEffectChance(user,target,effectChance=0)
+    return 0 if target.hasActiveAbility?(:SHIELDDUST) && !@battle.moldBreaker
+    ret = (effectChance>0) ? effectChance : @addlEffect
+    if Settings::MECHANICS_GENERATION >= 6 || @function != "0A4"   # Secret Power
+      ret *= 2 if user.hasActiveAbility?(:SERENEGRACE) ||
+                  user.pbOwnSide.effects[PBEffects::Rainbow]>0
+    end
+    ret = 100 if $DEBUG && Input.press?(Input::CTRL)
+    return ret
+  end
+
+  # NOTE: Flinching caused by a move's effect is applied in that move's code,
+  #       not here.
+  def pbFlinchChance(user,target)
+    return 0 if flinchingMove?
+    return 0 if target.hasActiveAbility?(:SHIELDDUST) && !@battle.moldBreaker
+    ret = 0
+    if user.hasActiveAbility?(:STENCH,true)
+      ret = 10
+    elsif user.hasActiveItem?([:KINGSROCK,:RAZORFANG],true)
+      ret = 10
+    end
+    ret *= 2 if user.hasActiveAbility?(:SERENEGRACE) ||
+                user.pbOwnSide.effects[PBEffects::Rainbow]>0
+    return ret
+  end
+end

Data/Scripts/011_Battle/002_Move/004_Move_Effects_Generic.rb

@@ -0,0 +1,716 @@
+#===============================================================================
+# Superclass that handles moves using a non-existent function code.
+# Damaging moves just do damage with no additional effect.
+# Status moves always fail.
+#===============================================================================
+class PokeBattle_UnimplementedMove < PokeBattle_Move
+  def pbMoveFailed?(user,targets)
+    if statusMove?
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    return false
+  end
+end
+
+
+
+#===============================================================================
+# Pseudomove for confusion damage.
+#===============================================================================
+class PokeBattle_Confusion < PokeBattle_Move
+  def initialize(battle,move)
+    @battle     = battle
+    @realMove   = move
+    @id         = 0
+    @name       = ""
+    @function   = "000"
+    @baseDamage = 40
+    @type       = -1
+    @category   = 0
+    @accuracy   = 100
+    @pp         = -1
+    @target     = 0
+    @priority   = 0
+    @flags      = ""
+    @addlEffect = 0
+    @calcType   = nil
+    @powerBoost = false
+    @snatched   = false
+  end
+
+  def physicalMove?(thisType=nil);    return true;  end
+  def specialMove?(thisType=nil);     return false; end
+  def pbCritialOverride(user,target); return -1;    end
+end
+
+
+
+#===============================================================================
+# Implements the move Struggle.
+# For cases where the real move named Struggle is not defined.
+#===============================================================================
+class PokeBattle_Struggle < PokeBattle_Move
+  def initialize(battle,move)
+    @battle     = battle
+    @realMove   = nil                     # Not associated with a move
+    @id         = (move) ? move.id : :STRUGGLE
+    @name       = (move) ? move.name : _INTL("Struggle")
+    @function   = "002"
+    @baseDamage = 50
+    @type       = -1
+    @category   = 0
+    @accuracy   = 0
+    @pp         = -1
+    @target     = 0
+    @priority   = 0
+    @flags      = ""
+    @addlEffect = 0
+    @calcType   = nil
+    @powerBoost = false
+    @snatched   = false
+  end
+
+  def physicalMove?(thisType=nil); return true;  end
+  def specialMove?(thisType=nil);  return false; end
+
+  def pbEffectAfterAllHits(user,target)
+    return if target.damageState.unaffected
+    user.pbReduceHP((user.totalhp/4.0).round,false)
+    @battle.pbDisplay(_INTL("{1} is damaged by recoil!",user.pbThis))
+    user.pbItemHPHealCheck
+  end
+end
+
+
+
+#===============================================================================
+# Generic status problem-inflicting classes.
+#===============================================================================
+class PokeBattle_SleepMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanSleep?(user,true,self)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbSleep
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    target.pbSleep if target.pbCanSleep?(user,false,self)
+  end
+end
+
+
+
+class PokeBattle_PoisonMove < PokeBattle_Move
+  def initialize(battle,move)
+    super
+    @toxic = false
+  end
+
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanPoison?(user,true,self)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbPoison(user,nil,@toxic)
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    target.pbPoison(user,nil,@toxic) if target.pbCanPoison?(user,false,self)
+  end
+end
+
+
+
+class PokeBattle_ParalysisMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanParalyze?(user,true,self)
+  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
+
+
+
+class PokeBattle_BurnMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanBurn?(user,true,self)
+  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
+
+
+
+class PokeBattle_FreezeMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanFreeze?(user,true,self)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbFreeze
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    target.pbFreeze if target.pbCanFreeze?(user,false,self)
+  end
+end
+
+
+
+#===============================================================================
+# Other problem-causing classes.
+#===============================================================================
+class PokeBattle_FlinchMove < PokeBattle_Move
+  def flinchingMove?; return true; end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbFlinch(user)
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    target.pbFlinch(user)
+  end
+end
+
+
+
+class PokeBattle_ConfuseMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanConfuse?(user,true,self)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbConfuse
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    return if !target.pbCanConfuse?(user,false,self)
+    target.pbConfuse
+  end
+end
+
+
+
+#===============================================================================
+# Generic user's stat increase/decrease classes.
+#===============================================================================
+class PokeBattle_StatUpMove < PokeBattle_Move
+  def pbMoveFailed?(user,targets)
+    return false if damagingMove?
+    return !user.pbCanRaiseStatStage?(@statUp[0],user,self,true)
+  end
+
+  def pbEffectGeneral(user)
+    return if damagingMove?
+    user.pbRaiseStatStage(@statUp[0],@statUp[1],user)
+  end
+
+  def pbAdditionalEffect(user,target)
+    if user.pbCanRaiseStatStage?(@statUp[0],user,self)
+      user.pbRaiseStatStage(@statUp[0],@statUp[1],user)
+    end
+  end
+end
+
+
+
+class PokeBattle_MultiStatUpMove < PokeBattle_Move
+  def pbMoveFailed?(user,targets)
+    return false if damagingMove?
+    failed = true
+    for i in 0...@statUp.length/2
+      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
+      failed = false
+      break
+    end
+    if failed
+      @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!",user.pbThis))
+      return true
+    end
+    return false
+  end
+
+  def pbEffectGeneral(user)
+    return if damagingMove?
+    showAnim = true
+    for i in 0...@statUp.length/2
+      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
+      if user.pbRaiseStatStage(@statUp[i*2],@statUp[i*2+1],user,showAnim)
+        showAnim = false
+      end
+    end
+  end
+
+  def pbAdditionalEffect(user,target)
+    showAnim = true
+    for i in 0...@statUp.length/2
+      next if !user.pbCanRaiseStatStage?(@statUp[i*2],user,self)
+      if user.pbRaiseStatStage(@statUp[i*2],@statUp[i*2+1],user,showAnim)
+        showAnim = false
+      end
+    end
+  end
+end
+
+
+
+class PokeBattle_StatDownMove < PokeBattle_Move
+  def pbEffectWhenDealingDamage(user,target)
+    return if @battle.pbAllFainted?(target.idxOwnSide)
+    showAnim = true
+    for i in 0...@statDown.length/2
+      next if !user.pbCanLowerStatStage?(@statDown[i*2],user,self)
+      if user.pbLowerStatStage(@statDown[i*2],@statDown[i*2+1],user,showAnim)
+        showAnim = false
+      end
+    end
+  end
+end
+
+
+
+#===============================================================================
+# Generic target's stat increase/decrease classes.
+#===============================================================================
+class PokeBattle_TargetStatDownMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    return !target.pbCanLowerStatStage?(@statDown[0],user,self,true)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    target.pbLowerStatStage(@statDown[0],@statDown[1],user)
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    return if !target.pbCanLowerStatStage?(@statDown[0],user,self)
+    target.pbLowerStatStage(@statDown[0],@statDown[1],user)
+  end
+end
+
+
+
+class PokeBattle_TargetMultiStatDownMove < PokeBattle_Move
+  def pbFailsAgainstTarget?(user,target)
+    return false if damagingMove?
+    failed = true
+    for i in 0...@statDown.length/2
+      next if !target.pbCanLowerStatStage?(@statDown[i*2],user,self)
+      failed = false
+      break
+    end
+    if failed
+      # NOTE: It's a bit of a faff to make sure the appropriate failure message
+      #       is shown here, I know.
+      canLower = false
+      if target.hasActiveAbility?(:CONTRARY) && !@battle.moldBreaker
+        for i in 0...@statDown.length/2
+          next if target.statStageAtMax?(@statDown[i*2])
+          canLower = true
+          break
+        end
+        @battle.pbDisplay(_INTL("{1}'s stats won't go any higher!",user.pbThis)) if !canLower
+      else
+        for i in 0...@statDown.length/2
+          next if target.statStageAtMin?(@statDown[i*2])
+          canLower = true
+          break
+        end
+        @battle.pbDisplay(_INTL("{1}'s stats won't go any lower!",user.pbThis)) if !canLower
+      end
+      if canLower
+        target.pbCanLowerStatStage?(@statDown[0],user,self,true)
+      end
+      return true
+    end
+    return false
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    return if damagingMove?
+    showAnim = true
+    for i in 0...@statDown.length/2
+      next if !target.pbCanLowerStatStage?(@statDown[i*2],user,self)
+      if target.pbLowerStatStage(@statDown[i*2],@statDown[i*2+1],user,showAnim)
+        showAnim = false
+      end
+    end
+  end
+
+  def pbAdditionalEffect(user,target)
+    return if target.damageState.substitute
+    showAnim = true
+    for i in 0...@statDown.length/2
+      next if !target.pbCanLowerStatStage?(@statDown[i*2],user,self)
+      if target.pbLowerStatStage(@statDown[i*2],@statDown[i*2+1],user,showAnim)
+        showAnim = false
+      end
+    end
+  end
+end
+
+
+
+#===============================================================================
+# Fixed damage-inflicting move.
+#===============================================================================
+class PokeBattle_FixedDamageMove < PokeBattle_Move
+  def pbFixedDamage(user,target); return 1; end
+
+  def pbCalcDamage(user,target,numTargets=1)
+    target.damageState.critical   = false
+    target.damageState.calcDamage = pbFixedDamage(user,target)
+    target.damageState.calcDamage = 1 if target.damageState.calcDamage<1
+  end
+end
+
+
+
+#===============================================================================
+# Two turn move.
+#===============================================================================
+class PokeBattle_TwoTurnMove < PokeBattle_Move
+  def chargingTurnMove?; return true; end
+
+  # user.effects[PBEffects::TwoTurnAttack] is set to the move's ID if this
+  # method returns true, or nil if false.
+  # Non-nil means the charging turn. nil means the attacking turn.
+  def pbIsChargingTurn?(user)
+    @powerHerb = false
+    @chargingTurn = false   # Assume damaging turn by default
+    @damagingTurn = true
+    # 0 at start of charging turn, move's ID at start of damaging turn
+    if !user.effects[PBEffects::TwoTurnAttack]
+      @powerHerb = user.hasActiveItem?(:POWERHERB)
+      @chargingTurn = true
+      @damagingTurn = @powerHerb
+    end
+    return !@damagingTurn   # Deliberately not "return @chargingTurn"
+  end
+
+  def pbDamagingMove?   # Stops damage being dealt in the first (charging) turn
+    return false if !@damagingTurn
+    return super
+  end
+
+  def pbAccuracyCheck(user,target)
+    return true if !@damagingTurn
+    return super
+  end
+
+  def pbInitialEffect(user,targets,hitNum)
+    pbChargingTurnMessage(user,targets) if @chargingTurn
+    if @chargingTurn && @damagingTurn   # Move only takes one turn to use
+      pbShowAnimation(@id,user,targets,1)   # Charging anim
+      targets.each { |b| pbChargingTurnEffect(user,b) }
+      if @powerHerb
+        # Moves that would make the user semi-invulnerable will hide the user
+        # after the charging animation, so the "UseItem" animation shouldn't show
+        # for it
+        if !["0C9","0CA","0CB","0CC","0CD","0CE","14D"].include?(@function)
+          @battle.pbCommonAnimation("UseItem",user)
+        end
+        @battle.pbDisplay(_INTL("{1} became fully charged due to its Power Herb!",user.pbThis))
+        user.pbConsumeItem
+      end
+    end
+    pbAttackingTurnMessage(user,targets) if @damagingTurn
+  end
+
+  def pbChargingTurnMessage(user,targets)
+    @battle.pbDisplay(_INTL("{1} began charging up!",user.pbThis))
+  end
+
+  def pbAttackingTurnMessage(user,targets)
+  end
+
+  def pbChargingTurnEffect(user,target)
+    # Skull Bash/Sky Drop are the only two-turn moves with an effect here, and
+    # the latter just records the target is being Sky Dropped
+  end
+
+  def pbAttackingTurnEffect(user,target)
+  end
+
+  def pbEffectAgainstTarget(user,target)
+    if @damagingTurn;    pbAttackingTurnEffect(user,target)
+    elsif @chargingTurn; pbChargingTurnEffect(user,target)
+    end
+  end
+
+  def pbShowAnimation(id,user,targets,hitNum=0,showAnimation=true)
+    hitNum = 1 if @chargingTurn && !@damagingTurn   # Charging anim
+    super
+  end
+end
+
+
+
+#===============================================================================
+# Healing move.
+#===============================================================================
+class PokeBattle_HealingMove < PokeBattle_Move
+  def healingMove?;       return true; end
+  def pbHealAmount(user); return 1;    end
+
+  def pbMoveFailed?(user,targets)
+    if user.hp==user.totalhp
+      @battle.pbDisplay(_INTL("{1}'s HP is full!",user.pbThis))
+      return true
+    end
+    return false
+  end
+
+  def pbEffectGeneral(user)
+    amt = pbHealAmount(user)
+    user.pbRecoverHP(amt)
+    @battle.pbDisplay(_INTL("{1}'s HP was restored.",user.pbThis))
+  end
+end
+
+
+
+#===============================================================================
+# Recoil move.
+#===============================================================================
+class PokeBattle_RecoilMove < PokeBattle_Move
+  def recoilMove?;                 return true; end
+  def pbRecoilDamage(user,target); return 1;    end
+
+  def pbEffectAfterAllHits(user,target)
+    return if target.damageState.unaffected
+    return if !user.takesIndirectDamage?
+    return if user.hasActiveAbility?(:ROCKHEAD)
+    amt = pbRecoilDamage(user,target)
+    amt = 1 if amt<1
+    user.pbReduceHP(amt,false)
+    @battle.pbDisplay(_INTL("{1} is damaged by recoil!",user.pbThis))
+    user.pbItemHPHealCheck
+  end
+end
+
+
+
+#===============================================================================
+# Protect move.
+#===============================================================================
+class PokeBattle_ProtectMove < PokeBattle_Move
+  def initialize(battle,move)
+    super
+    @sidedEffect = false
+  end
+
+  def pbChangeUsageCounters(user,specialUsage)
+    oldVal = user.effects[PBEffects::ProtectRate]
+    super
+    user.effects[PBEffects::ProtectRate] = oldVal
+  end
+
+  def pbMoveFailed?(user,targets)
+    if @sidedEffect
+      if user.pbOwnSide.effects[@effect]
+        user.effects[PBEffects::ProtectRate] = 1
+        @battle.pbDisplay(_INTL("But it failed!"))
+        return true
+      end
+    elsif user.effects[@effect]
+      user.effects[PBEffects::ProtectRate] = 1
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    if (!@sidedEffect || Settings::MECHANICS_GENERATION <= 5) &&
+       user.effects[PBEffects::ProtectRate]>1 &&
+       @battle.pbRandom(user.effects[PBEffects::ProtectRate])!=0
+      user.effects[PBEffects::ProtectRate] = 1
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    if pbMoveFailedLastInRound?(user)
+      user.effects[PBEffects::ProtectRate] = 1
+      return true
+    end
+    return false
+  end
+
+  def pbEffectGeneral(user)
+    if @sidedEffect
+      user.pbOwnSide.effects[@effect] = true
+    else
+      user.effects[@effect] = true
+    end
+    user.effects[PBEffects::ProtectRate] *= (Settings::MECHANICS_GENERATION >= 6) ? 3 : 2
+    pbProtectMessage(user)
+  end
+
+  def pbProtectMessage(user)
+    if @sidedEffect
+      @battle.pbDisplay(_INTL("{1} protected {2}!",@name,user.pbTeam(true)))
+    else
+      @battle.pbDisplay(_INTL("{1} protected itself!",user.pbThis))
+    end
+  end
+end
+
+
+
+#===============================================================================
+# Weather-inducing move.
+#===============================================================================
+class PokeBattle_WeatherMove < PokeBattle_Move
+  def initialize(battle,move)
+    super
+    @weatherType = :None
+  end
+
+  def pbMoveFailed?(user,targets)
+    case @battle.field.weather
+    when :HarshSun
+      @battle.pbDisplay(_INTL("The extremely harsh sunlight was not lessened at all!"))
+      return true
+    when :HeavyRain
+      @battle.pbDisplay(_INTL("There is no relief from this heavy rain!"))
+      return true
+    when :StrongWinds
+      @battle.pbDisplay(_INTL("The mysterious air current blows on regardless!"))
+      return true
+    when @weatherType
+      @battle.pbDisplay(_INTL("But it failed!"))
+      return true
+    end
+    return false
+  end
+
+  def pbEffectGeneral(user)
+    @battle.pbStartWeather(user,@weatherType,true,false)
+  end
+end
+
+
+
+#===============================================================================
+# Pledge move.
+#===============================================================================
+class PokeBattle_PledgeMove < PokeBattle_Move
+  def pbOnStartUse(user,targets)
+    @pledgeSetup = false; @pledgeCombo = false; @pledgeOtherUser = nil
+    @comboEffect = nil; @overrideType = nil; @overrideAnim = nil
+    # Check whether this is the use of a combo move
+    @combos.each do |i|
+      next if i[0]!=user.effects[PBEffects::FirstPledge]
+      @battle.pbDisplay(_INTL("The two moves have become one! It's a combined move!"))
+      @pledgeCombo = true
+      @comboEffect = i[1]; @overrideType = i[2]; @overrideAnim = i[3]
+      @overrideType = nil if !GameData::Type.exists?(@overrideType)
+      break
+    end
+    return if @pledgeCombo
+    # Check whether this is the setup of a combo move
+    user.eachAlly do |b|
+      next if @battle.choices[b.index][0]!=:UseMove || b.movedThisRound?
+      move = @battle.choices[b.index][2]
+      next if !move
+      @combos.each do |i|
+        next if i[0]!=move.function
+        @pledgeSetup = true
+        @pledgeOtherUser = b
+        break
+      end
+      break if @pledgeSetup
+    end
+  end
+
+  def pbDamagingMove?
+    return false if @pledgeSetup
+    return super
+  end
+
+  def pbBaseType(user)
+    return @overrideType if @overrideType!=nil
+    return super
+  end
+
+  def pbBaseDamage(baseDmg,user,target)
+    baseDmg *= 2 if @pledgeCombo
+    return baseDmg
+  end
+
+  def pbEffectGeneral(user)
+    user.effects[PBEffects::FirstPledge] = 0
+    return if !@pledgeSetup
+    @battle.pbDisplay(_INTL("{1} is waiting for {2}'s move...",
+       user.pbThis,@pledgeOtherUser.pbThis(true)))
+    @pledgeOtherUser.effects[PBEffects::FirstPledge] = @function
+    @pledgeOtherUser.effects[PBEffects::MoveNext]    = true
+    user.lastMoveFailed = true   # Treated as a failure for Stomping Tantrum
+  end
+
+  def pbEffectAfterAllHits(user,target)
+    return if !@pledgeCombo
+    msg = nil; animName = nil
+    case @comboEffect
+    when :SeaOfFire   # Grass + Fire
+      if user.pbOpposingSide.effects[PBEffects::SeaOfFire]==0
+        user.pbOpposingSide.effects[PBEffects::SeaOfFire] = 4
+        msg = _INTL("A sea of fire enveloped {1}!",user.pbOpposingTeam(true))
+        animName = (user.opposes?) ? "SeaOfFire" : "SeaOfFireOpp"
+      end
+    when :Rainbow   # Fire + Water
+      if user.pbOwnSide.effects[PBEffects::Rainbow]==0
+        user.pbOwnSide.effects[PBEffects::Rainbow] = 4
+        msg = _INTL("A rainbow appeared in the sky on {1}'s side!",user.pbTeam(true))
+        animName = (user.opposes?) ? "RainbowOpp" : "Rainbow"
+      end
+    when :Swamp   # Water + Grass
+      if user.pbOpposingSide.effects[PBEffects::Swamp]==0
+        user.pbOpposingSide.effects[PBEffects::Swamp] = 4
+        msg = _INTL("A swamp enveloped {1}!",user.pbOpposingTeam(true))
+        animName = (user.opposes?) ? "Swamp" : "SwampOpp"
+      end
+    end
+    @battle.pbDisplay(msg) if msg
+    @battle.pbCommonAnimation(animName) if animName
+  end
+
+  def pbShowAnimation(id,user,targets,hitNum=0,showAnimation=true)
+    return if @pledgeSetup   # No animation for setting up
+    id = @overrideAnim if @overrideAnim
+    return super
+  end
+end