Changed AI's random move choice after scores are calculated

Data/Scripts/011_Battle/005_AI/004_AI_Move.rb

@@ -9,12 +9,9 @@ class Battle::AI
     choices = []
     # TODO: Split this into two, the first part being the calculation of all
     #       predicted damages and the second part being the score calculations
-    #       (which are based on the predicted damages). Note that this requires
+    #       (which are based on the predicted damages). Multi-target moves could
-    #       saving each of the scoresAndTargets entries in here rather than in
+    #       be fiddly since damages should be calculated for each target but
-    #       def pbRegisterMoveTrainer, and only at the very end are they
+    #       they're all related.
-    #       whittled down to one per move which are chosen from. Multi-target
-    #       moves could be fiddly since damages should be calculated for each
-    #       target but they're all related.
     battler.eachMoveWithIndex do |_m, i|
       next if !@battle.pbCanChooseMove?(battler.index, i, false)
       if @user.wild?
@@ -73,17 +70,11 @@ class Battle::AI
       choices.push([idxMove, totalScore, -1]) if totalScore > 0
     else
       # If move affects one battler and you have to choose which one
-      scoresAndTargets = []
       @battle.allBattlers.each do |b|
         next if !@battle.pbMoveCanTarget?(battler.index, b.index, target_data)
         next if target_data.targets_foe && !battler.opposes?(b)
         score = pbGetMoveScore(move, b)
-        scoresAndTargets.push([score, b.index]) if score > 0
+        choices.push([idxMove, score, b.index]) if score > 0
-      end
-      if scoresAndTargets.length > 0
-        # Get the one best target for the move
-        scoresAndTargets.sort! { |a, b| b[0] <=> a[0] }
-        choices.push([idxMove, scoresAndTargets[0][0], scoresAndTargets[0][1]])
       end
     end
   end
@@ -466,7 +457,7 @@ class Battle::AI
          "UserTargetSwapBaseSpeed",
          "RedirectAllMovesToTarget",
          "TargetUsesItsLastUsedMoveAgain"
-      return 5
+      return 55
     when "RaiseUserAttack1",
          "RaiseUserDefense1",
          "RaiseUserDefense1CurlUpUser",
@@ -490,7 +481,7 @@ class Battle::AI
          "LowerTargetAtkSpAtk1",
          "LowerTargetSpAtk1",
          "TargetNextFireMoveDamagesTarget"
-      return 10
+      return 60
     when "SleepTarget",
          "SleepTargetIfUserDarkrai",
          "SleepTargetChangeUserMeloettaForm",
@@ -527,7 +518,7 @@ class Battle::AI
          "LowerTargetAtkSpAtk1SwitchOutUser",
          "RaisePlusMinusUserAndAlliesAtkSpAtk1",
          "HealTargetDependingOnGrassyTerrain"
-      return 15
+      return 65
     when "SleepTarget",
          "SleepTargetChangeUserMeloettaForm",
          "SleepTargetNextTurn",
@@ -553,7 +544,7 @@ class Battle::AI
          "TargetMovesBecomeElectric",
          "NormalMovesBecomeElectric",
          "PoisonTargetLowerTargetSpeed1"
-      return 20
+      return 70
     when "BadPoisonTarget",
          "ParalyzeTarget",
          "BurnTarget",
@@ -585,7 +576,7 @@ class Battle::AI
          "InvertTargetStatStages",
          "HealUserByTargetAttackLowerTargetAttack1",
          "HealUserDependingOnSandstorm"
-      return 25
+      return 75
     when "ParalyzeTarget",
          "ParalyzeTargetIfNotTypeImmune",
          "RaiseUserAtkDef1",
@@ -606,7 +597,7 @@ class Battle::AI
          "StartMistyTerrain",
          "StartPsychicTerrain",
          "CureTargetStatusHealUserHalfOfTotalHP"
-      return 30
+      return 80
     when "CureUserPartyStatus",
          "RaiseUserAttack2",
          "RaiseUserSpAtk2",
@@ -617,18 +608,18 @@ class Battle::AI
          "ProtectUserSideFromDamagingMovesIfUserFirstTurn",
          "ProtectUserFromDamagingMovesKingsShield",
          "ProtectUserBanefulBunker"
-      return 35
+      return 85
     when "RaiseUserAtkSpd1",
          "RaiseUserSpAtkSpDefSpd1",
          "LowerUserDefSpDef1RaiseUserAtkSpAtkSpd2",
          "RaiseUserAtk1Spd2",
          "TwoTurnAttackRaiseUserSpAtkSpDefSpd2"
-      return 40
+      return 90
     when "SleepTarget",
          "SleepTargetChangeUserMeloettaForm",
          "AddStickyWebToFoeSide",
          "StartWeakenDamageAgainstUserSideIfHail"
-      return 60
+      return 100
     end
     # "DoesNothingUnusableInGravity",
     # "StartUserSideImmunityToInflictedStatus",
@@ -644,7 +635,7 @@ class Battle::AI
     # "TargetActsNext",
     # "TargetActsLast",
     # "ProtectUserSideFromStatusMoves"
-    return 0
+    return 100
   end
 
   #=============================================================================
@@ -654,48 +645,33 @@ class Battle::AI
   def pbChooseMove(choices)
     user_battler = @user.battler
 
-    # Figure out useful information about the choices
+    # If there are no calculated choices, pick one at random
-    totalScore = 0
+    if choices.length == 0
-    maxScore   = 0
+      user_battler.eachMoveWithIndex do |_m, i|
-    choices.each do |c|
+        next if !@battle.pbCanChooseMove?(user_battler.index, i, false)
-      totalScore += c[1]
+        choices.push([i, 100, -1])   # Move index, score, target
-      maxScore = c[1] if maxScore < c[1]
       end
-
+      if choices.length == 0   # No moves are physically possible to use; use Struggle
-    # Find any preferred moves and just choose from them
+        @battle.pbAutoChooseMove(user_battler.index)
-    if @trainer.high_skill? && maxScore > 100
+        PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) will auto-use a move or Struggle")
-      stDev = pbStdDev(choices)
-      if stDev >= 40 && pbAIRandom(100) < 90
-        preferredMoves = []
-        choices.each do |c|
-          next if c[1] < 200 && c[1] < maxScore * 0.8
-          preferredMoves.push(c)
-          preferredMoves.push(c) if c[1] == maxScore   # Doubly prefer the best move
-        end
-        if preferredMoves.length > 0
-          m = preferredMoves[pbAIRandom(preferredMoves.length)]
-          PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) prefers #{user_battler.moves[m[0]].name}")
-          @battle.pbRegisterMove(user_battler.index, m[0], false)
-          @battle.pbRegisterTarget(user_battler.index, m[2]) if m[2] >= 0
         return
       end
+      PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) doesn't want to use any moves; picking one at random")
     end
-    end
+
+    # Figure out useful information about the choices
+    max_score = 0
+    choices.each { |c| max_score = c[1] if max_score < c[1] }
 
     # Decide whether all choices are bad, and if so, try switching instead
     if @trainer.high_skill? && @user.can_switch_lax?
       badMoves = false
-      if (maxScore <= 20 && user_battler.turnCount > 2) ||
+      if (max_score <= 20 && user_battler.turnCount > 2) ||
-         (maxScore <= 40 && user_battler.turnCount > 5)
+         (max_score <= 40 && user_battler.turnCount > 5)
         badMoves = true if pbAIRandom(100) < 80
       end
-      if !badMoves && totalScore < 100 && user_battler.turnCount > 1
+      if !badMoves && max_score < 60 && user_battler.turnCount > 1
-        badMoves = true
+        badMoves = choices.none? { |c| user_battler.moves[c[0]].damagingMove? }
-        choices.each do |c|
-          next if !user_battler.moves[c[0]].damagingMove?
-          badMoves = false
-          break
-        end
         badMoves = false if badMoves && pbAIRandom(100) < 10
       end
       if badMoves && pbEnemyShouldWithdrawEx?(true)
@@ -706,20 +682,13 @@ class Battle::AI
       end
     end
 
-    # If there are no calculated choices, pick one at random
+    # Calculate a minimum score threshold and reduce all move scores by it
-    if choices.length == 0
+    threshold = (max_score * 0.85).floor
-      PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) doesn't want to use any moves; picking one at random")
+    choices.each { |c| c[1] = [c[1] - threshold, 0].max }
-      user_battler.eachMoveWithIndex do |_m, i|
+    total_score = choices.sum { |c| c[1] }
-        next if !@battle.pbCanChooseMove?(user_battler.index, i, false)
-        choices.push([i, 100, -1])   # Move index, score, target
-      end
-      if choices.length == 0   # No moves are physically possible to use; use Struggle
-        @battle.pbAutoChooseMove(user_battler.index)
-      end
-    end
 
-    # Randomly choose a move from the choices and register it
+    # Pick a move randomly from choices weighted by their scores
-    randNum = pbAIRandom(totalScore)
+    randNum = pbAIRandom(total_score)
     choices.each do |c|
       randNum -= c[1]
       next if randNum >= 0
@@ -727,6 +696,7 @@ class Battle::AI
       @battle.pbRegisterTarget(user_battler.index, c[2]) if c[2] >= 0
       break
     end
+
     # Log the result
     if @battle.choices[user_battler.index][2]
       PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) will use #{@battle.choices[user_battler.index][2].name}")

Data/Scripts/011_Battle/005_AI/051_AI_MoveHandlers_Misc.rb

@@ -3,8 +3,14 @@
 #===============================================================================
 # Struggle
 
+#===============================================================================
+#
+#===============================================================================
 # None
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DoesNothingCongratulations",
   proc { |score, move, user, target, ai, battle|
     next 0 if ai.trainer.high_skill?
@@ -12,6 +18,9 @@ Battle::AI::Handlers::MoveEffectScore.add("DoesNothingCongratulations",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DoesNothingFailsIfNoAlly",
   proc { |move, user, target, ai, battle|
     next true if user.battler.allAllies.length == 0
@@ -20,18 +29,35 @@ Battle::AI::Handlers::MoveFailureCheck.add("DoesNothingFailsIfNoAlly",
 Battle::AI::Handlers::MoveEffectScore.copy("DoesNothingCongratulations",
                                            "DoesNothingFailsIfNoAlly")
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveEffectScore.copy("DoesNothingCongratulations",
+                                           "DoesNothingUnusableInGravity")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("DoesNothingCongratulations",
-                                           "DoesNothingUnusableInGravity",
                                            "DoubleMoneyGainedFromBattle")
 
+#===============================================================================
+#
+#===============================================================================
 # AddMoneyGainedFromBattle
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FailsIfNotUserFirstTurn",
   proc { |move, user, target, ai, battle|
     next true if user.turnCount > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FailsIfUserHasUnusedMove",
   proc { |move, user, target, ai, battle|
     has_another_move = false
@@ -47,12 +73,18 @@ Battle::AI::Handlers::MoveFailureCheck.add("FailsIfUserHasUnusedMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FailsIfUserNotConsumedBerry",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.belched?
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FailsIfTargetHasNoItem",
   proc { |move, user, target, ai, battle|
     next true if !target.item || !target.item_active?
@@ -64,6 +96,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FailsIfTargetHasNoItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FailsUnlessTargetSharesTypeWithUser",
   proc { |move, user, target, ai, battle|
     user_types = user.battler.pbTypes(true)
@@ -72,6 +107,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("FailsUnlessTargetSharesTypeWithUser"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("FailsIfUserDamagedThisTurn",
   proc { |score, move, user, target, ai, battle|
     score += 50 if target.effects[PBEffects::HyperBeam] > 0
@@ -81,14 +119,23 @@ Battle::AI::Handlers::MoveEffectScore.add("FailsIfUserDamagedThisTurn",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # FailsIfTargetActed
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("CrashDamageIfFailsUnusableInGravity",
   proc { |score, move, user, target, ai, battle|
     next score + 10 * (user.stages[:ACCURACY] - target.stages[:EVASION])
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartSunWeather",
   proc { |move, user, target, ai, battle|
     next true if [:HarshSun, :HeavyRain, :StrongWinds,
@@ -110,6 +157,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartSunWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("StartSunWeather",
                                             "StartRainWeather")
 Battle::AI::Handlers::MoveEffectScore.add("StartRainWeather",
@@ -127,6 +177,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartRainWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("StartSunWeather",
                                             "StartSandstormWeather")
 Battle::AI::Handlers::MoveEffectScore.add("StartSandstormWeather",
@@ -138,6 +191,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartSandstormWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("StartSunWeather",
                                             "StartHailWeather")
 Battle::AI::Handlers::MoveEffectScore.add("StartHailWeather",
@@ -149,36 +205,54 @@ Battle::AI::Handlers::MoveEffectScore.add("StartHailWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartElectricTerrain",
   proc { |move, user, target, ai, battle|
     next true if battle.field.terrain == :Electric
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartGrassyTerrain",
   proc { |move, user, target, ai, battle|
     next true if battle.field.terrain == :Grassy
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartMistyTerrain",
   proc { |move, user, target, ai, battle|
     next true if battle.field.terrain == :Misty
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartPsychicTerrain",
   proc { |move, user, target, ai, battle|
     next true if battle.field.terrain == :Psychic
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RemoveTerrain",
   proc { |move, user, target, ai, battle|
     next true if battle.field.terrain == :None
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddSpikesToFoeSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOpposingSide.effects[PBEffects::Spikes] >= 3
@@ -196,6 +270,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AddSpikesToFoeSide",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddToxicSpikesToFoeSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOpposingSide.effects[PBEffects::ToxicSpikes] >= 2
@@ -213,6 +290,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AddToxicSpikesToFoeSide",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddStealthRocksToFoeSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOpposingSide.effects[PBEffects::StealthRock]
@@ -228,12 +308,18 @@ Battle::AI::Handlers::MoveEffectScore.add("AddStealthRocksToFoeSide",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddStickyWebToFoeSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOpposingSide.effects[PBEffects::StickyWeb]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SwapSideEffects",
   proc { |move, user, target, ai, battle|
     has_effect = false
@@ -277,6 +363,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SwapSideEffects",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserMakeSubstitute",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Substitute] > 0
@@ -284,6 +373,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("UserMakeSubstitute",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RemoveUserBindingAndEntryHazards",
   proc { |score, move, user, target, ai, battle|
     score += 30 if user.effects[PBEffects::Trapping] > 0
@@ -297,6 +389,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RemoveUserBindingAndEntryHazards",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AttackTwoTurnsLater",
   proc { |move, user, target, ai, battle|
     next true if battle.positions[target.index].effects[PBEffects::FutureSightCounter] > 0
@@ -311,6 +406,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AttackTwoTurnsLater",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserSwapsPositionsWithAlly",
   proc { |move, user, target, ai, battle|
     num_targets = 0
@@ -324,6 +422,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("UserSwapsPositionsWithAlly",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("BurnAttackerBeforeUserActs",
   proc { |score, move, user, target, ai, battle|
     next score + 20   # Because of possible burning

Data/Scripts/011_Battle/005_AI/052_AI_MoveHandlers_BattlerStats.rb

@@ -40,6 +40,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAttack1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAttack1",
                                             "RaiseUserAttack2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAttack2",
@@ -78,17 +81,29 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAttack2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAttack2",
                                            "RaiseUserAttack2IfTargetFaints")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAttack2",
                                             "RaiseUserAttack3")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAttack2",
                                            "RaiseUserAttack3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAttack2IfTargetFaints",
                                            "RaiseUserAttack3IfTargetFaints")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("MaxUserAttackLoseHalfOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if user.hp <= [user.totalhp / 2, 1].max
@@ -115,6 +130,9 @@ Battle::AI::Handlers::MoveEffectScore.add("MaxUserAttackLoseHalfOfTotalHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAttack1",
                                             "RaiseUserDefense1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense1",
@@ -127,11 +145,17 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserDefense1",
                                             "RaiseUserDefense1CurlUpUser")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserDefense1",
                                            "RaiseUserDefense1CurlUpUser")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserDefense1",
                                             "RaiseUserDefense2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense2",
@@ -147,6 +171,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserDefense1",
                                             "RaiseUserDefense3")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense3",
@@ -162,6 +189,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefense3",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAttack1",
                                             "RaiseUserSpAtk1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk1",
@@ -197,6 +227,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpAtk1",
                                             "RaiseUserSpAtk2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk2",
@@ -234,6 +267,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpAtk1",
                                             "RaiseUserSpAtk3")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk3",
@@ -271,6 +307,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtk3",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserDefense1",
                                             "RaiseUserSpDef1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpDef1",
@@ -286,6 +325,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpDef1",
                                             "RaiseUserSpDef1PowerUpElectricMove")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpDef1PowerUpElectricMove",
@@ -306,13 +348,25 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpDef1PowerUpElectricMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpDef1",
+                                            "RaiseUserSpDef2")
+Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserSpDef1",
+                                           "RaiseUserSpDef2")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpDef1",
-                                            "RaiseUserSpDef2",
                                             "RaiseUserSpDef3")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserSpDef1",
-                                           "RaiseUserSpDef2",
                                            "RaiseUserSpDef3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpDef1",
                                             "RaiseUserSpeed1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpeed1",
@@ -331,6 +385,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpeed1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpeed1",
                                             "RaiseUserSpeed2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpeed2",
@@ -351,13 +408,25 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpeed2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpeed2",
+                                            "RaiseUserSpeed2LowerUserWeight")
+Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserSpeed2",
+                                           "RaiseUserSpeed2LowerUserWeight")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpeed2",
-                                            "RaiseUserSpeed2LowerUserWeight",
                                             "RaiseUserSpeed3")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserSpeed2",
-                                           "RaiseUserSpeed2LowerUserWeight",
                                            "RaiseUserSpeed3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserSpeed1",
                                             "RaiseUserAccuracy1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAccuracy1",
@@ -373,13 +442,25 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAccuracy1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAccuracy1",
+                                            "RaiseUserAccuracy2")
+Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAccuracy1",
+                                           "RaiseUserAccuracy2")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAccuracy1",
-                                            "RaiseUserAccuracy2",
                                             "RaiseUserAccuracy3")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAccuracy1",
-                                           "RaiseUserAccuracy2",
                                            "RaiseUserAccuracy3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAccuracy1",
                                             "RaiseUserEvasion1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserEvasion1",
@@ -393,6 +474,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserEvasion1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserEvasion1",
                                             "RaiseUserEvasion2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserEvasion2",
@@ -408,13 +492,25 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserEvasion2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserEvasion2",
+                                            "RaiseUserEvasion2MinimizeUser")
+Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserEvasion2",
+                                           "RaiseUserEvasion2MinimizeUser")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserEvasion2",
-                                            "RaiseUserEvasion2MinimizeUser",
                                             "RaiseUserEvasion3")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserEvasion2",
-                                           "RaiseUserEvasion2MinimizeUser",
                                            "RaiseUserEvasion3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseUserCriticalHitRate2",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::FocusEnergy] >= 2
@@ -428,6 +524,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserCriticalHitRate2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseUserAtkDef1",
   proc { |move, user, target, ai, battle|
     if move.statusMove?
@@ -462,6 +561,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkDef1",
                                             "RaiseUserAtkDefAcc1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkDefAcc1",
@@ -486,6 +588,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkDefAcc1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkDef1",
                                             "RaiseUserAtkSpAtk1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkSpAtk1",
@@ -512,11 +617,17 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserAtkSpAtk1Or2InSun")
 Battle::AI::Handlers::MoveEffectScore.copy("RaiseUserAtkSpAtk1",
                                            "RaiseUserAtkSpAtk1Or2InSun")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerUserDefSpDef1RaiseUserAtkSpAtkSpd2",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -553,6 +664,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefSpDef1RaiseUserAtkSpAtkSp
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserAtkSpd1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkSpd1",
@@ -582,6 +696,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkSpd1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserAtk1Spd2")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtk1Spd2",
@@ -610,6 +727,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtk1Spd2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserAtkAcc1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkAcc1",
@@ -633,6 +753,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserAtkAcc1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserDefSpDef1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefSpDef1",
@@ -643,6 +766,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserDefSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserSpAtkSpDef1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtkSpDef1",
@@ -667,6 +793,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtkSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserSpAtkSpDefSpd1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtkSpDefSpd1",
@@ -697,6 +826,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserSpAtkSpDefSpd1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("RaiseUserAtkSpAtk1",
                                             "RaiseUserMainStats1")
 Battle::AI::Handlers::MoveEffectScore.add("RaiseUserMainStats1",
@@ -715,6 +847,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserMainStats1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseUserMainStats1LoseThirdOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if user.hp <= [user.totalhp / 3, 1].max
@@ -740,6 +875,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserMainStats1LoseThirdOfTotalHP
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseUserMainStats1TrapUserInBattle",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::NoRetreat]
@@ -768,57 +906,93 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseUserMainStats1TrapUserInBattle",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("StartRaiseUserAtk1WhenDamaged",
   proc { |score, move, user, target, ai, battle|
     next score + 25 if user.effects[PBEffects::Rage]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserAttack1",
   proc { |score, move, user, target, ai, battle|
     next score + user.stages[:ATTACK] * 10
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("LowerUserAttack1",
                                            "LowerUserAttack2")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefense1",
   proc { |score, move, user, target, ai, battle|
     next score + user.stages[:DEFENSE] * 10
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("LowerUserDefense1",
                                            "LowerUserDefense2")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserSpAtk1",
   proc { |score, move, user, target, ai, battle|
     next score + user.stages[:SPECIAL_ATTACK] * 10
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("LowerUserSpAtk1",
                                            "LowerUserSpAtk2")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserSpDef1",
   proc { |score, move, user, target, ai, battle|
     next score + user.stages[:SPECIAL_DEFENSE] * 10
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("LowerUserSpDef1",
                                            "LowerUserSpDef2")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserSpeed1",
   proc { |score, move, user, target, ai, battle|
     next score + user.stages[:SPECIAL_DEFENSE] * 10
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("LowerUserSpeed1",
                                            "LowerUserSpeed2")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserAtkDef1",
   proc { |score, move, user, target, ai, battle|
     avg =  user.stages[:ATTACK] * 10
@@ -827,6 +1001,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerUserAtkDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefSpDef1",
   proc { |score, move, user, target, ai, battle|
     avg =  user.stages[:DEFENSE] * 10
@@ -835,6 +1012,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefSpDefSpd1",
   proc { |score, move, user, target, ai, battle|
     avg =  user.stages[:DEFENSE] * 10
@@ -844,6 +1024,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerUserDefSpDefSpd1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetAttack1",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? &&
@@ -851,6 +1034,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetAttack1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetAttack2ConfuseTarget",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.pbCanRaiseStatStage?(:ATTACK, user.battler, move.move) &&
@@ -864,6 +1050,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseTargetAttack2ConfuseTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetSpAtk1ConfuseTarget",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user.battler, move.move) &&
@@ -877,6 +1066,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseTargetSpAtk1ConfuseTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetSpDef1",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.pbCanRaiseStatStage?(:SPECIAL_DEFENSE, user.battler, move.move)
@@ -888,6 +1080,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseTargetSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetRandomStat2",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -909,6 +1104,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseTargetRandomStat2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseTargetAtkSpAtk2",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.pbCanRaiseStatStage?(:ATTACK, user.battler, move.move) &&
@@ -925,6 +1123,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseTargetAtkSpAtk2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetAttack1",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? &&
@@ -964,6 +1165,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAttack1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAttack1",
                                             "LowerTargetAttack1BypassSubstitute")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAttack1BypassSubstitute",
@@ -986,6 +1190,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAttack1BypassSubstitute",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAttack1",
                                             "LowerTargetAttack2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAttack2",
@@ -1023,11 +1230,17 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAttack2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAttack2",
                                             "LowerTargetAttack3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetAttack2",
                                            "LowerTargetAttack3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAttack1",
                                             "LowerTargetDefense1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetDefense1",
@@ -1041,6 +1254,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetDefense1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetDefense1",
                                             "LowerTargetDefense1PowersUpInGravity")
 Battle::AI::Handlers::MoveBasePower.add("LowerTargetDefense1PowersUpInGravity",
@@ -1059,6 +1275,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetDefense1PowersUpInGravity"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetDefense1",
                                             "LowerTargetDefense2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetDefense2",
@@ -1074,11 +1293,17 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetDefense2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetDefense2",
                                             "LowerTargetDefense3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetDefense2",
                                            "LowerTargetDefense3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAttack1",
                                             "LowerTargetSpAtk1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk1",
@@ -1114,6 +1339,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpAtk1",
                                             "LowerTargetSpAtk2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk2",
@@ -1124,6 +1352,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetSpAtk2IfCanAttract",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? &&
@@ -1167,6 +1398,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk2IfCanAttract",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpAtk1",
                                             "LowerTargetSpAtk3")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk3",
@@ -1177,6 +1411,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpAtk3",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetDefense1",
                                             "LowerTargetSpDef1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpDef1",
@@ -1190,6 +1427,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpDef1",
                                             "LowerTargetSpDef2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpDef2",
@@ -1205,11 +1445,17 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpDef2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpDef2",
                                             "LowerTargetSpDef3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetSpDef2",
                                            "LowerTargetSpDef3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpDef1",
                                             "LowerTargetSpeed1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpeed1",
@@ -1228,6 +1474,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpeed1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpeed1",
                                             "LowerTargetSpeed1WeakerInGrassyTerrain")
 Battle::AI::Handlers::MoveBasePower.add("LowerTargetSpeed1WeakerInGrassyTerrain",
@@ -1238,6 +1487,9 @@ Battle::AI::Handlers::MoveBasePower.add("LowerTargetSpeed1WeakerInGrassyTerrain"
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetSpeed1",
                                            "LowerTargetSpeed1WeakerInGrassyTerrain")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetSpeed1MakeTargetWeakerToFire",
   proc { |move, user, target, ai, battle|
     next false if !target.effects[PBEffects::TarShot]
@@ -1258,6 +1510,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpeed1MakeTargetWeakerToFi
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpeed1",
                                             "LowerTargetSpeed2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpeed2",
@@ -1278,11 +1533,17 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetSpeed2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpeed2",
                                             "LowerTargetSpeed3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetSpeed2",
                                            "LowerTargetSpeed3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetSpeed1",
                                             "LowerTargetAccuracy1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAccuracy1",
@@ -1296,13 +1557,25 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAccuracy1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAccuracy1",
+                                            "LowerTargetAccuracy2")
+Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetAccuracy1",
+                                           "LowerTargetAccuracy2")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAccuracy1",
-                                            "LowerTargetAccuracy2",
                                             "LowerTargetAccuracy3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetAccuracy1",
-                                           "LowerTargetAccuracy2",
                                            "LowerTargetAccuracy3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAccuracy1",
                                             "LowerTargetEvasion1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetEvasion1",
@@ -1316,6 +1589,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetEvasion1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetEvasion1RemoveSideEffects",
   proc { |move, user, target, ai, battle|
     target_side = target.pbOwnSide
@@ -1358,6 +1634,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetEvasion1RemoveSideEffects"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetEvasion1",
                                             "LowerTargetEvasion2")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetEvasion2",
@@ -1371,11 +1650,17 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetEvasion2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetEvasion2",
                                             "LowerTargetEvasion3")
 Battle::AI::Handlers::MoveEffectScore.copy("LowerTargetEvasion2",
                                            "LowerTargetEvasion3")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetAtkDef1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1395,6 +1680,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAtkDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("LowerTargetAtkDef1",
                                             "LowerTargetAtkSpAtk1")
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAtkSpAtk1",
@@ -1405,6 +1693,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAtkSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerPoisonedTargetAtkSpAtkSpd1",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.poisoned?
@@ -1426,6 +1717,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerPoisonedTargetAtkSpAtkSpd1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseAlliesAtkDef1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1454,6 +1748,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseAlliesAtkDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaisePlusMinusUserAndAlliesAtkSpAtk1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1480,6 +1777,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaisePlusMinusUserAndAlliesAtkSpAtk1"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaisePlusMinusUserAndAlliesAtkSpAtk1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1506,6 +1806,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaisePlusMinusUserAndAlliesDefSpDef1"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseGroundedGrassBattlersAtkSpAtk1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1533,6 +1836,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseGroundedGrassBattlersAtkSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RaiseGrassBattlersDef1",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -1558,6 +1864,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RaiseGrassBattlersDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapAtkSpAtkStages",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1578,6 +1887,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapAtkSpAtkStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapDefSpDefStages",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1598,6 +1910,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapDefSpDefStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapStatStages",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1615,6 +1930,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapStatStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserCopyTargetStatStages",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1632,7 +1950,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserCopyTargetStatStages",
   }
 )
 
+#===============================================================================
 # TODO: Account for stat theft before damage calculation.
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserStealTargetPositiveStatStages",
   proc { |score, move, user, target, ai, battle|
     numStages = 0
@@ -1644,6 +1964,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserStealTargetPositiveStatStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("InvertTargetStatStages",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.hasAlteredStatStages?
@@ -1662,6 +1985,9 @@ Battle::AI::Handlers::MoveEffectScore.add("InvertTargetStatStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ResetTargetStatStages",
   proc { |score, move, user, target, ai, battle|
     next 0 if target.effects[PBEffects::Substitute] > 0
@@ -1677,6 +2003,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ResetTargetStatStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ResetAllBattlersStatStages",
   proc { |move, user, target, ai, battle|
     next true if battle.allBattlers.none? { |b| b.hasAlteredStatStages? }
@@ -1700,12 +2029,18 @@ Battle::AI::Handlers::MoveEffectScore.add("ResetAllBattlersStatStages",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartUserSideImmunityToStatStageLowering",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::Mist] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserSwapBaseAtkDef",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1726,6 +2061,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserSwapBaseAtkDef",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapBaseSpeed",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1739,6 +2077,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapBaseSpeed",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageBaseAtkSpAtk",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1760,6 +2101,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageBaseAtkSpAtk",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageBaseDefSpDef",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -1781,6 +2125,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageBaseDefSpDef",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageHP",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::Substitute] > 0
@@ -1794,10 +2141,16 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetAverageHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartUserSideDoubleSpeed",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::Tailwind] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # StartSwapAllBattlersBaseDefensiveStats

Data/Scripts/011_Battle/005_AI/053_AI_MoveHandlers_BattlerOther.rb

@@ -23,6 +23,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SleepTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SleepTargetIfUserDarkrai",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.isSpecies?(:DARKRAI) && user.effects[PBEffects::TransformSpecies] != :DARKRAI
@@ -32,9 +35,15 @@ Battle::AI::Handlers::MoveFailureCheck.add("SleepTargetIfUserDarkrai",
 Battle::AI::Handlers::MoveEffectScore.copy("SleepTarget",
                                            "SleepTargetIfUserDarkrai")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("SleepTarget",
                                            "SleepTargetChangeUserMeloettaForm")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SleepTargetNextTurn",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Yawn] > 0
@@ -55,6 +64,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SleepTargetNextTurn",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("PoisonTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.pbCanPoison?(user.battler, false, move.move)
@@ -77,6 +89,9 @@ Battle::AI::Handlers::MoveEffectScore.add("PoisonTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("PoisonTargetLowerTargetSpeed1",
   proc { |move, user, target, ai, battle|
     next true if !target.pbCanPoison?(user.battler, false, move.move) &&
@@ -110,6 +125,9 @@ Battle::AI::Handlers::MoveEffectScore.add("PoisonTargetLowerTargetSpeed1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("PoisonTarget",
                                             "BadPoisonTarget")
 Battle::AI::Handlers::MoveEffectScore.add("BadPoisonTarget",
@@ -129,6 +147,9 @@ Battle::AI::Handlers::MoveEffectScore.add("BadPoisonTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ParalyzeTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.pbCanParalyze?(user.battler, false, move.move)
@@ -151,6 +172,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ParalyzeTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ParalyzeTargetIfNotTypeImmune",
   proc { |move, user, target, ai, battle|
     eff = target.effectiveness_of_type_against_battler(move.rough_type, user)
@@ -161,10 +185,16 @@ Battle::AI::Handlers::MoveFailureCheck.add("ParalyzeTargetIfNotTypeImmune",
 Battle::AI::Handlers::MoveEffectScore.copy("ParalyzeTarget",
                                            "ParalyzeTargetIfNotTypeImmune")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("ParalyzeTarget",
                                            "ParalyzeTargetAlwaysHitsInRainHitsTargetInSky",
                                            "ParalyzeFlinchTarget")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("BurnTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.pbCanBurn?(user.battler, false, move.move)
@@ -178,10 +208,21 @@ Battle::AI::Handlers::MoveEffectScore.add("BurnTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveEffectScore.copy("BurnTarget",
+                                           "BurnTargetIfTargetStatsRaisedThisTurn")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("BurnTarget",
-                                           "BurnTargetIfTargetStatsRaisedThisTurn",
                                            "BurnFlinchTarget")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FreezeTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.pbCanFreeze?(user.battler, false, move.move)
@@ -195,6 +236,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FreezeTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("FreezeTargetSuperEffectiveAgainstWater",
   proc { |score, move, user, target, ai, battle|
     if target.battler.pbCanFreeze?(user.battler, false)
@@ -205,6 +249,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FreezeTargetSuperEffectiveAgainstWate
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("FreezeTargetAlwaysHitsInHail",
   proc { |score, move, user, target, ai, battle|
     if target.battler.pbCanFreeze?(user.battler, false)
@@ -217,15 +264,24 @@ Battle::AI::Handlers::MoveEffectScore.add("FreezeTargetAlwaysHitsInHail",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("FreezeTargetAlwaysHitsInHail",
                                            "FreezeFlinchTarget")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ParalyzeBurnOrFreezeTarget",
   proc { |score, move, user, target, ai, battle|
     next score + 30 if target.status == :NONE
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("GiveUserStatusToTarget",
   proc { |move, user, target, ai, battle|
     next true if user.status == :NONE
@@ -238,6 +294,9 @@ Battle::AI::Handlers::MoveEffectScore.add("GiveUserStatusToTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("CureUserBurnPoisonParalysis",
   proc { |move, user, target, ai, battle|
     next true if ![:BURN, :POISON, :PARALYSIS].include?(user.status)
@@ -263,6 +322,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CureUserBurnPoisonParalysis",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("CureUserPartyStatus",
   proc { |move, user, target, ai, battle|
     has_effect = battle.allSameSideBattlers(user.battler).any? { |b| b.status != :NONE }
@@ -283,6 +345,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CureUserPartyStatus",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("CureTargetBurn",
   proc { |score, move, user, target, ai, battle|
     if target.opposes?(user)
@@ -294,6 +359,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CureTargetBurn",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartUserSideImmunityToInflictedStatus",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::Safeguard] > 0
@@ -310,6 +378,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartUserSideImmunityToInflictedStatu
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("FlinchTarget",
   proc { |score, move, user, target, ai, battle|
     next score + 30 if !target.has_active_ability?(:INNERFOCUS) &&
@@ -317,6 +388,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FlinchTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FlinchTargetFailsIfUserNotAsleep",
   proc { |move, user, target, ai, battle|
     next true if !user.asleep?
@@ -331,6 +405,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FlinchTargetFailsIfUserNotAsleep",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("FlinchTargetFailsIfNotUserFirstTurn",
   proc { |move, user, target, ai, battle|
     next true if user.turnCount > 0
@@ -343,6 +420,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FlinchTargetFailsIfNotUserFirstTurn",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("FlinchTargetDoublePowerIfTargetInSky",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
@@ -356,6 +436,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FlinchTargetDoublePowerIfTargetInSky"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ConfuseTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.battler.pbCanConfuse?(user.battler, false, move.move)
@@ -367,9 +450,15 @@ Battle::AI::Handlers::MoveEffectScore.add("ConfuseTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.copy("ConfuseTarget",
                                            "ConfuseTargetAlwaysHitsInRainHitsTargetInSky")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AttractTarget",
   proc { |move, user, target, ai, battle|
     next true if move.statusMove? && !target.battler.pbCanAttract?(user.battler, false)
@@ -386,6 +475,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AttractTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesBasedOnEnvironment",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canChangeType?
@@ -430,6 +522,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesBasedOnEnvironment",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToResistLastAttack",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canChangeType?
@@ -446,6 +541,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToResistLastAttack",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToTargetTypes",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canChangeType?
@@ -455,6 +553,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToTargetTypes",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToUserMoveType",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canChangeType?
@@ -470,6 +571,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetUserTypesToUserMoveType",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetTargetTypesToPsychic",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.canChangeType?
@@ -478,6 +582,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetTargetTypesToPsychic",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetTargetTypesToWater",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.canChangeType?
@@ -485,6 +592,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetTargetTypesToWater",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddGhostTypeToTarget",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.canChangeType?
@@ -492,6 +602,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("AddGhostTypeToTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AddGrassTypeToTarget",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.canChangeType?
@@ -499,12 +612,18 @@ Battle::AI::Handlers::MoveFailureCheck.add("AddGrassTypeToTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserLosesFireType",
   proc { |move, user, target, ai, battle|
     next true if !user.has_type?(:FIRE)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetTargetAbilityToSimple",
   proc { |move, user, target, ai, battle|
     next true if !GameData::Ability.exists?(:SIMPLE)
@@ -513,6 +632,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetTargetAbilityToSimple",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetTargetAbilityToInsomnia",
   proc { |move, user, target, ai, battle|
     next true if !GameData::Ability.exists?(:INSOMNIA)
@@ -521,6 +643,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("SetTargetAbilityToInsomnia",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetUserAbilityToTargetAbility",
   proc { |move, user, target, ai, battle|
     next true if user.battle.unstoppableAbility?
@@ -539,6 +664,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SetUserAbilityToTargetAbility",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SetTargetAbilityToUserAbility",
   proc { |move, user, target, ai, battle|
     next true if !user.ability || user.ability_id == target.ability_id
@@ -557,6 +685,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SetTargetAbilityToUserAbility",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserTargetSwapAbilities",
   proc { |move, user, target, ai, battle|
     next true if !user.ability || !target.ability
@@ -577,6 +708,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapAbilities",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("NegateTargetAbility",
   proc { |move, user, target, ai, battle|
     next true if target.unstoppableAbility? ||
@@ -584,6 +718,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("NegateTargetAbility",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("NegateTargetAbilityIfTargetActed",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -595,8 +732,14 @@ Battle::AI::Handlers::MoveEffectScore.add("NegateTargetAbilityIfTargetActed",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # IgnoreTargetAbility
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartUserAirborne",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Ingrain] ||
@@ -605,6 +748,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("StartUserAirborne",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartTargetAirborneAndAlwaysHitByMoves",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Ingrain] ||
@@ -618,8 +764,14 @@ Battle::AI::Handlers::MoveFailureCheck.add("StartTargetAirborneAndAlwaysHitByMov
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # HitsTargetInSky
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("HitsTargetInSkyGroundsTarget",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -635,6 +787,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HitsTargetInSkyGroundsTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartGravity",
   proc { |move, user, target, ai, battle|
     next true if battle.field.effects[PBEffects::Gravity] > 0
@@ -664,6 +819,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartGravity",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TransformUserIntoTarget",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Transform]

Data/Scripts/011_Battle/005_AI/054_AI_MoveHandlers_MoveAttributes.rb

@@ -17,6 +17,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FixedDamage20",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("FixedDamage40",
   proc { |power, move, user, target, ai, battle|
     next move.pbFixedDamage(user.battler, target.battler)
@@ -28,6 +31,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FixedDamage40",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("FixedDamageHalfTargetHP",
   proc { |power, move, user, target, ai, battle|
     next move.pbFixedDamage(user.battler, target.battler)
@@ -40,6 +46,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FixedDamageHalfTargetHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("FixedDamageUserLevel",
   proc { |power, move, user, target, ai, battle|
     next move.pbFixedDamage(user.battler, target.battler)
@@ -51,6 +60,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FixedDamageUserLevel",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("FixedDamageUserLevelRandom",
   proc { |power, move, user, target, ai, battle|
     next user.level   # Average power
@@ -62,6 +74,9 @@ Battle::AI::Handlers::MoveEffectScore.add("FixedDamageUserLevelRandom",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetHPToUserHP",
   proc { |move, user, target, ai, battle|
     next true if user.hp >= target.hp
@@ -74,15 +89,13 @@ Battle::AI::Handlers::MoveBasePower.add("LowerTargetHPToUserHP",
 )
 Battle::AI::Handlers::MoveEffectScore.add("LowerTargetHPToUserHP",
   proc { |score, move, user, target, ai, battle|
-    if user.hp >= target.hp
+    next score + 50 if user.hp < target.hp / 2
-      score -= 90
-    elsif user.hp < target.hp / 2
-      score += 50
-    end
-    next score
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("OHKO",
   proc { |move, user, target, ai, battle|
     next true if target.level > user.level
@@ -95,6 +108,9 @@ Battle::AI::Handlers::MoveBasePower.add("OHKO",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("OHKOIce",
   proc { |move, user, target, ai, battle|
     next true if target.level > user.level
@@ -107,11 +123,17 @@ Battle::AI::Handlers::MoveBasePower.copy("OHKO",
 Battle::AI::Handlers::MoveEffectScore.copy("OHKO",
                                            "OHKOIce")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("OHKO",
                                          "OHKOHitsUndergroundTarget")
 Battle::AI::Handlers::MoveEffectScore.copy("OHKO",
                                            "OHKOHitsUndergroundTarget")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DamageTargetAlly",
   proc { |score, move, user, target, ai, battle|
     target.battler.allAllies.each do |b|
@@ -122,22 +144,66 @@ Battle::AI::Handlers::MoveEffectScore.add("DamageTargetAlly",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithUserHP",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerLowerWithUserHP")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerHigherWithTargetHP")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerHigherWithUserHappiness")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerLowerWithUserHappiness")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerHigherWithUserPositiveStatStages")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerHigherWithTargetPositiveStatStages")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
+                                         "PowerHigherWithUserFasterThanTarget")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithUserHP",
-                                         "PowerLowerWithUserHP",
-                                         "PowerHigherWithTargetHP",
-                                         "PowerHigherWithUserHappiness",
-                                         "PowerLowerWithUserHappiness",
-                                         "PowerHigherWithUserPositiveStatStages",
-                                         "PowerHigherWithTargetPositiveStatStages",
-                                         "PowerHigherWithUserFasterThanTarget",
                                          "PowerHigherWithTargetFasterThanUser")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithLessPP",
   proc { |power, move, user, target, ai, battle|
     next 0 if move.move.pp == 0 && move.move.totalpp > 0
@@ -147,27 +213,42 @@ Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithLessPP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithTargetWeight",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("PowerHigherWithTargetWeight",
                                          "PowerHigherWithUserHeavierThanTarget")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithConsecutiveUse",
   proc { |power, move, user, target, ai, battle|
     next power << user.effects[PBEffects::FuryCutter]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("PowerHigherWithConsecutiveUseOnUserSide",
   proc { |power, move, user, target, ai, battle|
     next power * (user.pbOwnSide.effects[PBEffects::EchoedVoiceCounter] + 1)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("RandomPowerDoublePowerIfTargetUnderground",
   proc { |power, move, user, target, ai, battle|
     power = 71   # Average damage
@@ -175,15 +256,24 @@ Battle::AI::Handlers::MoveBasePower.add("RandomPowerDoublePowerIfTargetUndergrou
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfTargetHPLessThanHalf",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetHPLessThanHalf",
                                          "DoublePowerIfUserPoisonedBurnedParalyzed")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetHPLessThanHalf",
                                          "DoublePowerIfTargetAsleepCureTarget")
 Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetAsleepCureTarget",
@@ -193,12 +283,18 @@ Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetAsleepCureTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfTargetPoisoned",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetPoisoned",
                                          "DoublePowerIfTargetParalyzedCureTarget")
 Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetParalyzedCureTarget",
@@ -207,62 +303,111 @@ Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetParalyzedCureTarge
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfTargetStatusProblem",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfUserHasNoItem",
   proc { |power, move, user, target, ai, battle|
     next power * 2 if !user.item || user.has_active_item?(:FLYINGGEM)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfTargetUnderwater",
   proc { |power, move, user, target, ai, battle|
     next move.pbModifyDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetUnderwater",
                                          "DoublePowerIfTargetUnderground")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("DoublePowerIfTargetInSky",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetInSky",
+                                         "DoublePowerInElectricTerrain")
+
+#===============================================================================
+#
+#===============================================================================
+Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetInSky",
+                                         "DoublePowerIfUserLastMoveFailed")
+
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("DoublePowerIfTargetInSky",
-                                         "DoublePowerInElectricTerrain",
-                                         "DoublePowerIfUserLastMoveFailed",
                                          "DoublePowerIfAllyFaintedLastTurn")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfUserLostHPThisTurn",
   proc { |score, move, user, target, ai, battle|
     next score + 30 if target.faster_than?(user)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetLostHPThisTurn",
   proc { |score, move, user, target, ai, battle|
     next score + 20 if battle.pbOpposingBattlerCount(user.battler) > 1
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # DoublePowerIfUserStatsLoweredThisTurn
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DoublePowerIfTargetActed",
   proc { |score, move, user, target, ai, battle|
     next score + 30 if target.faster_than?(user)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # DoublePowerIfTargetNotActed
 
+#===============================================================================
+#
+#===============================================================================
 # AlwaysCriticalHit
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("EnsureNextCriticalHit",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::LaserFocus] > 0
@@ -274,18 +419,27 @@ Battle::AI::Handlers::MoveEffectScore.add("EnsureNextCriticalHit",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("EnsureNextCriticalHit",
   proc { |score, move, user, target, ai, battle|
     next 0 if user.pbOwnSide.effects[PBEffects::LuckyChant] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartPreventCriticalHitsAgainstUserSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::LuckyChant] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("CannotMakeTargetFaint",
   proc { |move, user, target, ai, battle|
     next true if target.hp == 1
@@ -303,6 +457,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CannotMakeTargetFaint",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserEnduresFaintingThisTurn",
   proc { |score, move, user, target, ai, battle|
     score -= 25 if user.hp > user.totalhp / 2
@@ -316,6 +473,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserEnduresFaintingThisTurn",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartWeakenElectricMoves",
   proc { |move, user, target, ai, battle|
     if Settings::MECHANICS_GENERATION >= 6
@@ -331,6 +491,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartWeakenElectricMoves",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartWeakenFireMoves",
   proc { |move, user, target, ai, battle|
     if Settings::MECHANICS_GENERATION >= 6
@@ -346,18 +509,27 @@ Battle::AI::Handlers::MoveEffectScore.add("StartWeakenFireMoves",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartWeakenPhysicalDamageAgainstUserSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::Reflect] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartWeakenSpecialDamageAgainstUserSide",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::LightScreen] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartWeakenDamageAgainstUserSideIfHail",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::AuroraVeil] > 0
@@ -370,6 +542,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartWeakenDamageAgainstUserSideIfHai
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RemoveScreens",
   proc { |score, move, user, target, ai, battle|
     score += 20 if user.pbOpposingSide.effects[PBEffects::AuroraVeil] > 0
@@ -379,6 +554,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RemoveScreens",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ProtectUser",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::ProtectRate] > 1 ||
@@ -395,6 +573,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUser",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ProtectUserBanefulBunker",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::ProtectRate] > 1 ||
@@ -412,6 +593,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserBanefulBunker",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesKingsShield",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::ProtectRate] > 1 ||
@@ -428,6 +612,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesKingsShie
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesObstruct",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::ProtectRate] > 1 ||
@@ -444,6 +631,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesObstruct"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromTargetingMovesSpikyShield",
   proc { |score, move, user, target, ai, battle|
     if user.effects[PBEffects::ProtectRate] > 1 ||
@@ -460,6 +650,9 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromTargetingMovesSpikyShi
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ProtectUserSideFromDamagingMovesIfUserFirstTurn",
   proc { |move, user, target, ai, battle|
     next true if user.turnCount > 0
@@ -471,20 +664,38 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserSideFromDamagingMovesIfUse
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ProtectUserSideFromStatusMoves",
   proc { |move, user, target, ai, battle|
     next true if user.pbOwnSide.effects[PBEffects::CraftyShield]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # ProtectUserSideFromPriorityMoves
 
+#===============================================================================
+#
+#===============================================================================
 # ProtectUserSideFromMultiTargetDamagingMoves
 
+#===============================================================================
+#
+#===============================================================================
 # RemoveProtections
 
+#===============================================================================
+#
+#===============================================================================
 # RemoveProtectionsBypassSubstitute
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HoopaRemoveProtectionsBypassSubstituteLowerUserDef1",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.isSpecies?(:HOOPA) || user.battler.form != 1
@@ -496,12 +707,18 @@ Battle::AI::Handlers::MoveEffectScore.add("HoopaRemoveProtectionsBypassSubstitut
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RecoilQuarterOfDamageDealt",
   proc { |score, move, user, target, ai, battle|
     next score - 25
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RecoilThirdOfDamageDealtParalyzeTarget",
   proc { |score, move, user, target, ai, battle|
     score -= 30
@@ -522,6 +739,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RecoilThirdOfDamageDealtParalyzeTarge
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RecoilThirdOfDamageDealtBurnTarget",
   proc { |score, move, user, target, ai, battle|
     score -= 30
@@ -533,12 +753,18 @@ Battle::AI::Handlers::MoveEffectScore.add("RecoilThirdOfDamageDealtBurnTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RecoilHalfOfDamageDealt",
   proc { |score, move, user, target, ai, battle|
     next score - 40
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("EffectivenessIncludesFlyingType",
   proc { |power, move, user, target, ai, battle|
     if GameData::Type.exists?(:FLYING)
@@ -557,26 +783,47 @@ Battle::AI::Handlers::MoveBasePower.add("EffectivenessIncludesFlyingType",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("CategoryDependsOnHigherDamagePoisonTarget",
   proc { |score, move, user, target, ai, battle|
     next score + 5 if target.battler.pbCanPoison?(user.battler, false)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # CategoryDependsOnHigherDamageIgnoreTargetAbility
 
+#===============================================================================
+#
+#===============================================================================
 # UseUserBaseDefenseInsteadOfUserBaseAttack
 
+#===============================================================================
+#
+#===============================================================================
 # UseTargetAttackInsteadOfUserAttack
 
+#===============================================================================
+#
+#===============================================================================
 # UseTargetDefenseInsteadOfTargetSpDef
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("EnsureNextMoveAlwaysHits",
   proc { |score, move, user, target, ai, battle|
     next score - 50 if user.effects[PBEffects::LockOn] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("StartNegateTargetEvasionStatStageAndGhostImmunity",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::Foresight]
@@ -590,6 +837,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartNegateTargetEvasionStatStageAndG
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("StartNegateTargetEvasionStatStageAndDarkImmunity",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::MiracleEye]
@@ -603,16 +853,28 @@ Battle::AI::Handlers::MoveEffectScore.add("StartNegateTargetEvasionStatStageAndD
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # IgnoreTargetDefSpDefEvaStatStages
 
+#===============================================================================
+#
+#===============================================================================
 # TypeIsUserFirstType
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("TypeDependsOnUserIVs",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TypeAndPowerDependOnUserBerry",
   proc { |move, user, target, ai, battle|
     item = user.item
@@ -628,12 +890,24 @@ Battle::AI::Handlers::MoveBasePower.add("TypeAndPowerDependOnUserBerry",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # TypeDependsOnUserPlate
 
+#===============================================================================
+#
+#===============================================================================
 # TypeDependsOnUserMemory
 
+#===============================================================================
+#
+#===============================================================================
 # TypeDependsOnUserDrive
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TypeDependsOnUserMorpekoFormRaiseUserSpeed1",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.isSpecies?(:MORPEKO) && user.effects[PBEffects::TransformSpecies] != :MORPEKO
@@ -645,12 +919,18 @@ Battle::AI::Handlers::MoveEffectScore.add("TypeDependsOnUserMorpekoFormRaiseUser
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("TypeAndPowerDependOnWeather",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("TypeAndPowerDependOnWeather",
                                          "TypeAndPowerDependOnTerrain")
 Battle::AI::Handlers::MoveEffectScore.add("TypeAndPowerDependOnTerrain",
@@ -659,10 +939,16 @@ Battle::AI::Handlers::MoveEffectScore.add("TypeAndPowerDependOnTerrain",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TargetMovesBecomeElectric",
   proc { |score, move, user, target, ai, battle|
     next 0 if user.faster_than?(target)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # NormalMovesBecomeElectric

Data/Scripts/011_Battle/005_AI/055_AI_MoveHandlers_MultiHit.rb

@@ -1,13 +1,15 @@
 #===============================================================================
 #
 #===============================================================================
-
 Battle::AI::Handlers::MoveBasePower.add("HitTwoTimes",
   proc { |power, move, user, target, ai, battle|
     next power * move.pbNumHits(user.battler, [target.battler])
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("HitTwoTimes",
                                          "HitTwoTimesPoisonTarget")
 Battle::AI::Handlers::MoveEffectScore.add("HitTwoTimesPoisonTarget",
@@ -28,6 +30,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HitTwoTimesPoisonTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.copy("HitTwoTimes",
                                          "HitTwoTimesFlinchTarget")
 Battle::AI::Handlers::MoveEffectScore.add("HitTwoTimesFlinchTarget",
@@ -36,18 +41,27 @@ Battle::AI::Handlers::MoveEffectScore.add("HitTwoTimesFlinchTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitTwoTimesTargetThenTargetAlly",
   proc { |power, move, user, target, ai, battle|
     next power * 2
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitThreeTimesPowersUpWithEachHit",
   proc { |power, move, user, target, ai, battle|
     next power * 6   # Hits do x1, x2, x3 ret in turn, for x6 in total
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitThreeTimesAlwaysCriticalHit",
   proc { |power, move, user, target, ai, battle|
     next power * move.pbNumHits(user.battler, [target.battler])
@@ -62,6 +76,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HitThreeTimesAlwaysCriticalHit",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitTwoToFiveTimes",
   proc { |power, move, user, target, ai, battle|
     next power * 5 if user.has_active_ability?(:SKILLLINK)
@@ -69,6 +86,9 @@ Battle::AI::Handlers::MoveBasePower.add("HitTwoToFiveTimes",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitTwoToFiveTimesOrThreeForAshGreninja",
   proc { |power, move, user, target, ai, battle|
     if user.battler.isSpecies?(:GRENINJA) && user.battler.form == 2
@@ -79,6 +99,9 @@ Battle::AI::Handlers::MoveBasePower.add("HitTwoToFiveTimesOrThreeForAshGreninja"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitTwoToFiveTimesRaiseUserSpd1LowerUserDef1",
   proc { |power, move, user, target, ai, battle|
     next power * 5 if user.has_active_ability?(:SKILLLINK)
@@ -99,6 +122,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HitTwoToFiveTimesRaiseUserSpd1LowerUs
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HitOncePerUserTeamMember",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -120,16 +146,28 @@ Battle::AI::Handlers::MoveBasePower.add("HitOncePerUserTeamMember",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # AttackAndSkipNextTurn
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttack
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("TwoTurnAttackOneTurnInSun",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamageMultiplier(power, user.battler, target.battler)
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackParalyzeTarget",
   proc { |score, move, user, target, ai, battle|
     if target.battler.pbCanParalyze?(user.battler, false)
@@ -151,6 +189,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackParalyzeTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackBurnTarget",
   proc { |score, move, user, target, ai, battle|
     next 0 if !target.battler.pbCanBurn?(user.battler, false)
@@ -160,6 +201,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackBurnTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackFlinchTarget",
   proc { |score, move, user, target, ai, battle|
     score += 20 if user.effects[PBEffects::FocusEnergy] > 0
@@ -169,6 +213,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackFlinchTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TwoTurnAttackRaiseUserSpAtkSpDefSpd2",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.pbCanRaiseStatStage?(:SPECIAL_ATTACK, user.battler, move.move) &&
@@ -209,6 +256,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackRaiseUserSpAtkSpDefSpd2"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackChargeRaiseUserDefense1",
   proc { |score, move, user, target, ai, battle|
     if move.statusMove?
@@ -224,6 +274,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackChargeRaiseUserDefense1"
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackChargeRaiseUserSpAtk1",
   proc { |score, move, user, target, ai, battle|
     aspeed = user.rough_stat(:SPEED)
@@ -238,14 +291,29 @@ Battle::AI::Handlers::MoveEffectScore.add("TwoTurnAttackChargeRaiseUserSpAtk1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttackInvulnerableUnderground
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttackInvulnerableUnderwater
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttackInvulnerableInSky
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttackInvulnerableInSkyParalyzeTarget
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TwoTurnAttackInvulnerableInSkyTargetCannotAct",
   proc { |move, user, target, ai, battle|
     next true if !target.opposes?(user)
@@ -255,18 +323,33 @@ Battle::AI::Handlers::MoveFailureCheck.add("TwoTurnAttackInvulnerableInSkyTarget
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # TwoTurnAttackInvulnerableRemoveProtections
 
+#===============================================================================
+#
+#===============================================================================
 # MultiTurnAttackPreventSleeping
 
+#===============================================================================
+#
+#===============================================================================
 # MultiTurnAttackConfuseUserAtEnd
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("MultiTurnAttackPowersUpEachTurn",
   proc { |power, move, user, target, ai, battle|
     next power * 2 if user.effects[PBEffects::DefenseCurl]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("MultiTurnAttackBideThenReturnDoubleDamage",
   proc { |power, move, user, target, ai, battle|
     next 40   # Representative value

Data/Scripts/011_Battle/005_AI/056_AI_MoveHandlers_Healing.rb

@@ -17,6 +17,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserFullyAndFallAsleep",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserHalfOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canHeal?
@@ -30,6 +33,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserHalfOfTotalHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("HealUserHalfOfTotalHP",
                                             "HealUserDependingOnWeather")
 Battle::AI::Handlers::MoveEffectScore.add("HealUserDependingOnWeather",
@@ -47,6 +53,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserDependingOnWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("HealUserHalfOfTotalHP",
                                             "HealUserDependingOnSandstorm")
 Battle::AI::Handlers::MoveEffectScore.add("HealUserDependingOnSandstorm",
@@ -58,6 +67,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserDependingOnSandstorm",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("HealUserHalfOfTotalHP",
                                             "HealUserHalfOfTotalHPLoseFlyingTypeThisTurn")
 Battle::AI::Handlers::MoveEffectScore.add("HealUserHalfOfTotalHPLoseFlyingTypeThisTurn",
@@ -68,6 +80,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserHalfOfTotalHPLoseFlyingTypeTh
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("CureTargetStatusHealUserHalfOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.canHeal?
@@ -82,6 +97,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CureTargetStatusHealUserHalfOfTotalHP
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserByTargetAttackLowerTargetAttack1",
   proc { |move, user, target, ai, battle|
     if target.has_active_ability?(:CONTRARY)
@@ -114,6 +132,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserByTargetAttackLowerTargetAtta
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("HealUserByHalfOfDamageDone",
   proc { |score, move, user, target, ai, battle|
     if target.has_active_ability?(:LIQUIDOOZE)
@@ -125,6 +146,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserByHalfOfDamageDone",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserByHalfOfDamageDoneIfTargetAsleep",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.asleep?
@@ -141,6 +165,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserByHalfOfDamageDoneIfTargetAsl
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("HealUserByThreeQuartersOfDamageDone",
   proc { |score, move, user, target, ai, battle|
     if target.has_active_ability?(:LIQUIDOOZE)
@@ -152,6 +179,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserByThreeQuartersOfDamageDone",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserAndAlliesQuarterOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if battle.allSameSideBattlers(user.battler).none? { |b| b.canHeal? }
@@ -171,6 +201,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserAndAlliesQuarterOfTotalHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserAndAlliesQuarterOfTotalHPCureStatus",
   proc { |move, user, target, ai, battle|
     next true if battle.allSameSideBattlers(user.battler).none? { |b| b.canHeal? || b.status != :NONE }
@@ -191,6 +224,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserAndAlliesQuarterOfTotalHPCure
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealTargetHalfOfTotalHP",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.canHeal?
@@ -206,6 +242,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealTargetHalfOfTotalHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("HealTargetHalfOfTotalHP",
                                             "HealTargetDependingOnGrassyTerrain")
 Battle::AI::Handlers::MoveEffectScore.add("HealTargetDependingOnGrassyTerrain",
@@ -221,24 +260,36 @@ Battle::AI::Handlers::MoveEffectScore.add("HealTargetDependingOnGrassyTerrain",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserPositionNextTurn",
   proc { |move, user, target, ai, battle|
     next true if battle.positions[user.index].effects[PBEffects::Wish] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartHealUserEachTurn",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::AquaRing]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartHealUserEachTurnTrapUserInBattle",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Ingrain]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartDamageTargetEachTurnIfTargetAsleep",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.asleep? || target.effects[PBEffects::Nightmare]
@@ -256,6 +307,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartDamageTargetEachTurnIfTargetAsle
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartLeechSeedTarget",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::LeechSeed] >= 0
@@ -275,12 +329,18 @@ Battle::AI::Handlers::MoveEffectScore.add("StartLeechSeedTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserLosesHalfOfTotalHP",
   proc { |score, move, user, target, ai, battle|
     next 0 if user.hp <= user.totalhp / 2
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserLosesHalfOfTotalHPExplosive",
   proc { |move, user, target, ai, battle|
     next true if battle.pbCheckGlobalAbility(:DAMP)
@@ -301,6 +361,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserLosesHalfOfTotalHPExplosive",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("UserLosesHalfOfTotalHPExplosive",
                                             "UserFaintsExplosive")
 Battle::AI::Handlers::MoveEffectScore.add("UserFaintsExplosive",
@@ -318,6 +381,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserFaintsExplosive",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("UserLosesHalfOfTotalHPExplosive",
                                             "UserFaintsPowersUpInMistyTerrainExplosive")
 Battle::AI::Handlers::MoveBasePower.add("UserFaintsPowersUpInMistyTerrainExplosive",
@@ -340,12 +406,18 @@ Battle::AI::Handlers::MoveEffectScore.add("UserFaintsPowersUpInMistyTerrainExplo
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("UserFaintsFixedDamageUserHP",
   proc { |power, move, user, target, ai, battle|
     next user.hp
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserFaintsLowerTargetAtkSpAtk2",
   proc { |score, move, user, target, ai, battle|
     if !target.battler.pbCanLowerStatStage?(:ATTACK, user.battler) &&
@@ -362,6 +434,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserFaintsLowerTargetAtkSpAtk2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserFaintsHealAndCureReplacement",
   proc { |move, user, target, ai, battle|
     next true if !battle.pbCanChooseNonActive?(user.index)
@@ -373,11 +448,17 @@ Battle::AI::Handlers::MoveEffectScore.add("UserFaintsHealAndCureReplacement",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("UserFaintsHealAndCureReplacement",
                                             "UserFaintsHealAndCureReplacementRestorePP")
 Battle::AI::Handlers::MoveEffectScore.copy("UserFaintsHealAndCureReplacement",
                                            "UserFaintsHealAndCureReplacementRestorePP")
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartPerishCountsForAllBattlers",
   proc { |move, user, target, ai, battle|
     next target.effects[PBEffects::PerishSong] > 0
@@ -392,6 +473,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartPerishCountsForAllBattlers",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AttackerFaintsIfUserFaints",
   proc { |move, user, target, ai, battle|
     next Settings::MECHANICS_GENERATION >= 7 && user.effects[PBEffects::DestinyBondPrevious]
@@ -406,6 +490,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AttackerFaintsIfUserFaints",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("SetAttackerMovePPTo0IfUserFaints",
   proc { |score, move, user, target, ai, battle|
     score += 50

Data/Scripts/011_Battle/005_AI/057_AI_MoveHandlers_Items.rb

@@ -16,6 +16,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTakesTargetItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TargetTakesUserItem",
   proc { |move, user, target, ai, battle|
     next true if !user.item || user.battler.unlosableItem?(user.item)
@@ -34,6 +37,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TargetTakesUserItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserTargetSwapItems",
   proc { |move, user, target, ai, battle|
     next true if user.wild?
@@ -56,6 +62,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserTargetSwapItems",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RestoreUserConsumedItem",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.recycleItem || user.item
@@ -68,6 +77,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RestoreUserConsumedItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("RemoveTargetItem",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
@@ -82,6 +94,9 @@ Battle::AI::Handlers::MoveEffectScore.add("RemoveTargetItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DestroyTargetBerryOrGem",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::Substitute] == 0
@@ -112,6 +127,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CorrodeTargetItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("StartTargetCannotUseItem",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Embargo] > 0
@@ -123,6 +141,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartTargetCannotUseItem",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("StartNegateHeldItems",
   proc { |score, move, user, target, ai, battle|
     next 0 if battle.field.effects[PBEffects::MagicRoom] > 0
@@ -130,6 +151,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartNegateHeldItems",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserConsumeBerryRaiseDefense2",
   proc { |move, user, target, ai, battle|
     item = user.item
@@ -160,6 +184,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserConsumeBerryRaiseDefense2",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AllBattlersConsumeBerry",
   proc { |move, user, target, ai, battle|
     next true if !target.item || !target.item.is_berry? || target.battler.semiInvulnerable?
@@ -201,6 +228,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AllBattlersConsumeBerry",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserConsumeTargetBerry",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::Substitute] == 0
@@ -212,6 +242,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserConsumeTargetBerry",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ThrowUserItemAtTarget",
   proc { |move, user, target, ai, battle|
     item = user.item

Data/Scripts/011_Battle/005_AI/058_AI_MoveHandlers_ChangeMoveEffect.rb

@@ -7,12 +7,18 @@ Battle::AI::Handlers::MoveEffectScore.add("RedirectAllMovesToUser",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("RedirectAllMovesToTarget",
   proc { |score, move, user, target, ai, battle|
     next 0 if user.battler.allAllies.length == 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("CannotBeRedirected",
   proc { |score, move, user, target, ai, battle|
     redirection = false
@@ -32,12 +38,18 @@ Battle::AI::Handlers::MoveEffectScore.add("CannotBeRedirected",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("RandomlyDamageOrHealTarget",
   proc { |power, move, user, target, ai, battle|
     next 50   # Average power, ish
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealAllyOrDamageFoe",
   proc { |move, user, target, ai, battle|
     next true if !target.opposes?(user) && target.battler.canHeal?
@@ -53,6 +65,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HealAllyOrDamageFoe",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("CurseTargetOrLowerUserSpd1RaiseUserAtkDef1",
   proc { |move, user, target, ai, battle|
     if user.has_type?(:GHOST)
@@ -85,8 +100,14 @@ Battle::AI::Handlers::MoveEffectScore.add("CurseTargetOrLowerUserSpd1RaiseUserAt
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # EffectDependsOnEnvironment
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("HitsAllFoesAndPowersUpInPsychicTerrain",
   proc { |power, move, user, target, ai, battle|
     next move.pbBaseDamage(power, user.battler, target.battler)
@@ -98,6 +119,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HitsAllFoesAndPowersUpInPsychicTerrai
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TargetNextFireMoveDamagesTarget",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Powder]
@@ -116,10 +140,19 @@ Battle::AI::Handlers::MoveEffectScore.add("TargetNextFireMoveDamagesTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # DoublePowerAfterFusionFlare
 
+#===============================================================================
+#
+#===============================================================================
 # DoublePowerAfterFusionBolt
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("PowerUpAllyMove",
   proc { |move, user, target, ai, battle|
     next true if target.fainted? || target.effects[PBEffects::HelpingHand]
@@ -132,6 +165,9 @@ Battle::AI::Handlers::MoveEffectScore.add("PowerUpAllyMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("CounterPhysicalDamage",
   proc { |power, move, user, target, ai, battle|
     next 60   # Representative value
@@ -155,6 +191,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CounterPhysicalDamage",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("CounterSpecialDamage",
   proc { |power, move, user, target, ai, battle|
     next 60   # Representative value
@@ -178,6 +217,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CounterSpecialDamage",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("CounterDamagePlusHalf",
   proc { |power, move, user, target, ai, battle|
     next 60   # Representative value
@@ -189,6 +231,9 @@ Battle::AI::Handlers::MoveEffectScore.add("CounterDamagePlusHalf",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UserAddStockpileRaiseDefSpDef1",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Stockpile] >= 3
@@ -208,6 +253,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserAddStockpileRaiseDefSpDef1",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("PowerDependsOnUserStockpile",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Stockpile] == 0
@@ -219,6 +267,9 @@ Battle::AI::Handlers::MoveBasePower.add("PowerDependsOnUserStockpile",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("HealUserDependingOnUserStockpile",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Stockpile] == 0
@@ -236,12 +287,24 @@ Battle::AI::Handlers::MoveEffectScore.add("HealUserDependingOnUserStockpile",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # GrassPledge
 
+#===============================================================================
+#
+#===============================================================================
 # FirePledge
 
+#===============================================================================
+#
+#===============================================================================
 # WaterPledge
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UseLastMoveUsed",
   proc { |move, user, target, ai, battle|
     next true if !battle.lastMoveUsed
@@ -249,6 +312,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("UseLastMoveUsed",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UseLastMoveUsedByTarget",
   proc { |move, user, target, ai, battle|
     next true if !target.battle.lastRegularMoveUsed
@@ -261,12 +327,24 @@ Battle::AI::Handlers::MoveEffectScore.add("UseLastMoveUsedByTarget",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # UseMoveTargetIsAboutToUse
 
+#===============================================================================
+#
+#===============================================================================
 # UseMoveDependingOnEnvironment
 
+#===============================================================================
+#
+#===============================================================================
 # UseRandomMove
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UseRandomMoveFromUserParty",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -285,6 +363,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("UseRandomMoveFromUserParty",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("UseRandomUserMoveIfAsleep",
   proc { |move, user, target, ai, battle|
     next true if !user.battler.asleep?
@@ -304,10 +385,19 @@ Battle::AI::Handlers::MoveEffectScore.add("UseRandomUserMoveIfAsleep",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # BounceBackProblemCausingStatusMoves
 
+#===============================================================================
+#
+#===============================================================================
 # StealAndUseBeneficialStatusMove
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ReplaceMoveThisBattleWithTargetLastMoveUsed",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Transform] || user.battler.pbHasMove?(move.id)
@@ -319,6 +409,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("ReplaceMoveThisBattleWithTargetLastM
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("ReplaceMoveWithTargetLastMoveUsed",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Transform] || !user.battler.pbHasMove?(move.id)

Data/Scripts/011_Battle/005_AI/059_AI_MoveHandlers_SwitchingActing.rb

@@ -7,6 +7,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("FleeFromBattle",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SwitchOutUserStatusMove",
   proc { |move, user, target, ai, battle|
     if user.wild?
@@ -42,6 +45,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SwitchOutUserStatusMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("SwitchOutUserDamagingMove",
   proc { |score, move, user, target, ai, battle|
     next 0 if !battle.pbCanChooseNonActive?(user.index) ||
@@ -49,6 +55,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SwitchOutUserDamagingMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerTargetAtkSpAtk1SwitchOutUser",
   proc { |move, user, target, ai, battle|
     will_fail = true
@@ -69,6 +78,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerTargetAtkSpAtk1SwitchOutUser",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SwitchOutUserPassOnEffects",
   proc { |move, user, target, ai, battle|
     next true if !battle.pbCanChooseNonActive?(user.index)
@@ -100,6 +112,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SwitchOutUserPassOnEffects",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("SwitchOutTargetStatusMove",
   proc { |move, user, target, ai, battle|
     next true if target.has_active_ability?(:SUCTIONCUPS) ||
@@ -126,6 +141,9 @@ Battle::AI::Handlers::MoveEffectScore.add("SwitchOutTargetStatusMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("SwitchOutTargetDamagingMove",
   proc { |score, move, user, target, ai, battle|
     if !target.effects[PBEffects::Ingrain] &&
@@ -138,12 +156,18 @@ Battle::AI::Handlers::MoveEffectScore.add("SwitchOutTargetDamagingMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("BindTarget",
   proc { |score, move, user, target, ai, battle|
     next score + 40 if target.effects[PBEffects::Trapping] == 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveBasePower.add("BindTargetDoublePowerIfTargetUnderwater",
   proc { |power, move, user, target, ai, battle|
     next move.pbModifyDamage(power, user.battler, target.battler)
@@ -155,6 +179,9 @@ Battle::AI::Handlers::MoveEffectScore.add("BindTargetDoublePowerIfTargetUnderwat
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TrapTargetInBattle",
   proc { |move, user, target, ai, battle|
     if move.statusMove?
@@ -164,6 +191,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("TrapTargetInBattle",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TrapTargetInBattle",
   proc { |move, user, target, ai, battle|
     if move.statusMove?
@@ -181,6 +211,9 @@ Battle::AI::Handlers::MoveEffectScore.add("TrapTargetInBattleLowerTargetDefSpDef
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("TrapUserAndTargetInBattle",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::JawLock] < 0
@@ -190,14 +223,23 @@ Battle::AI::Handlers::MoveEffectScore.add("TrapUserAndTargetInBattle",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TrapAllBattlersInBattleForOneTurn",
   proc { |move, user, target, ai, battle|
     next true if battle.field.effects[PBEffects::FairyLock] > 0
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # PursueSwitchingFoe
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UsedAfterUserTakesPhysicalDamage",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -213,6 +255,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UsedAfterUserTakesPhysicalDamage",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UsedAfterAllyRoundWithDoublePower",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill?
@@ -225,10 +270,19 @@ Battle::AI::Handlers::MoveEffectScore.add("UsedAfterAllyRoundWithDoublePower",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # TargetActsNext
 
+#===============================================================================
+#
+#===============================================================================
 # TargetActsLast
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("TargetUsesItsLastUsedMoveAgain",
   proc { |move, user, target, ai, battle|
     next true if !target.battler.lastRegularMoveUsed ||
@@ -250,8 +304,14 @@ Battle::AI::Handlers::MoveEffectScore.add("TargetUsesItsLastUsedMoveAgain",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 # StartSlowerBattlersActFirst
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("HigherPriorityInGrassyTerrain",
   proc { |score, move, user, target, ai, battle|
     if ai.trainer.medium_skill? && @battle.field.terrain == :Grassy
@@ -261,6 +321,9 @@ Battle::AI::Handlers::MoveEffectScore.add("HigherPriorityInGrassyTerrain",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("LowerPPOfTargetLastMoveBy3",
   proc { |score, move, user, target, ai, battle|
     last_move = target.battler.pbGetMoveWithID(target.battler.lastRegularMoveUsed)
@@ -271,6 +334,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerPPOfTargetLastMoveBy3",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("LowerPPOfTargetLastMoveBy4",
   proc { |move, user, target, ai, battle|
     last_move = target.battler.pbGetMoveWithID(target.battler.lastRegularMoveUsed)
@@ -283,6 +349,9 @@ Battle::AI::Handlers::MoveEffectScore.add("LowerPPOfTargetLastMoveBy4",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetLastMoveUsed",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Disable] > 0 || !target.battler.lastRegularMoveUsed
@@ -298,6 +367,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetLastMoveUsed",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetUsingSameMoveConsecutively",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Torment]
@@ -310,6 +382,9 @@ Battle::AI::Handlers::MoveEffectScore.add("DisableTargetUsingSameMoveConsecutive
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetUsingDifferentMove",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Encore] > 0
@@ -344,6 +419,9 @@ Battle::AI::Handlers::MoveEffectScore.add("DisableTargetUsingDifferentMove",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetStatusMoves",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::Taunt] > 0
@@ -352,6 +430,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetStatusMoves",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetHealingMoves",
   proc { |move, user, target, ai, battle|
     next true if target.effects[PBEffects::HealBlock] > 0
@@ -359,6 +440,9 @@ Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetHealingMoves",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("DisableTargetSoundMoves",
   proc { |score, move, user, target, ai, battle|
     if target.effects[PBEffects::ThroatChop] == 0 && ai.trainer.high_skill?
@@ -374,12 +458,18 @@ Battle::AI::Handlers::MoveEffectScore.add("DisableTargetSoundMoves",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("DisableTargetMovesKnownByUser",
   proc { |move, user, target, ai, battle|
     next true if user.effects[PBEffects::Imprison]
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("AllBattlersLoseHalfHPUserSkipsNextTurn",
   proc { |move, user, target, ai, battle|
     next true if battle.allBattlers.none? { |b| b.hp > 1 }
@@ -394,6 +484,9 @@ Battle::AI::Handlers::MoveEffectScore.add("AllBattlersLoseHalfHPUserSkipsNextTur
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveEffectScore.add("UserLosesHalfHP",
   proc { |score, move, user, target, ai, battle|
     score += 20   # Shadow moves are more preferable
@@ -402,6 +495,9 @@ Battle::AI::Handlers::MoveEffectScore.add("UserLosesHalfHP",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.copy("StartSunWeather",
                                             "StartShadowSkyWeather")
 Battle::AI::Handlers::MoveEffectScore.add("StartShadowSkyWeather",
@@ -415,6 +511,9 @@ Battle::AI::Handlers::MoveEffectScore.add("StartShadowSkyWeather",
   }
 )
 
+#===============================================================================
+#
+#===============================================================================
 Battle::AI::Handlers::MoveFailureCheck.add("RemoveAllScreens",
   proc { |move, user, target, ai, battle|
     will_fail = true