DocRock3r/infinitefusion-e18
1
0
Fork 0
mirror of https://github.com/infinitefusion/infinitefusion-e18.git synced 2025-12-07 21:24:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Changed AI's random move choice after scores are calculated

Browse Source
This commit is contained in:
Maruno17
2022-08-27 20:37:05 +01:00
parent 265897f9e1
commit fbbddc8c2b
10 changed files with 1361 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
Data/Scripts/011_Battle/005_AI/004_AI_Move.rb
View File

@@ -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
# saving each of the scoresAndTargets entries in here rather than in
# def pbRegisterMoveTrainer, and only at the very end are they
# 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.
# (which are based on the predicted damages). 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
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]])
choices.push([idxMove, score, b.index]) if score > 0
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
totalScore = 0
maxScore = 0
choices.each do |c|
totalScore += c[1]
maxScore = c[1] if maxScore < c[1]
# If there are no calculated choices, pick one at random
if choices.length == 0
user_battler.eachMoveWithIndex do |_m, i|
next if !@battle.pbCanChooseMove?(user_battler.index, i, false)
choices.push([i, 100, -1]) # Move index, score, target
end
# Find any preferred moves and just choose from them
if @trainer.high_skill? && maxScore > 100
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
if choices.length == 0 # No moves are physically possible to use; use Struggle
@battle.pbAutoChooseMove(user_battler.index)
PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) will auto-use a move or Struggle")
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) ||
(maxScore <= 40 && user_battler.turnCount > 5)
if (max_score <= 20 && user_battler.turnCount > 2) ||
(max_score <= 40 && user_battler.turnCount > 5)
badMoves = true if pbAIRandom(100) < 80
end
if !badMoves && totalScore < 100 && user_battler.turnCount > 1
badMoves = true
choices.each do |c|
next if !user_battler.moves[c[0]].damagingMove?
badMoves = false
break
end
if !badMoves && max_score < 60 && user_battler.turnCount > 1
badMoves = choices.none? { |c| user_battler.moves[c[0]].damagingMove? }
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
if choices.length == 0
PBDebug.log("[AI] #{user_battler.pbThis} (#{user_battler.index}) doesn't want to use any moves; picking one at random")
user_battler.eachMoveWithIndex do |_m, i|
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
# Calculate a minimum score threshold and reduce all move scores by it
threshold = (max_score * 0.85).floor
choices.each { |c| c[1] = [c[1] - threshold, 0].max }
total_score = choices.sum { |c| c[1] }
# Randomly choose a move from the choices and register it
randNum = pbAIRandom(totalScore)
# Pick a move randomly from choices weighted by their scores
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}")

103
Data/Scripts/011_Battle/005_AI/051_AI_MoveHandlers_Misc.rb
View File

@@ -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

373
Data/Scripts/011_Battle/005_AI/052_AI_MoveHandlers_BattlerStats.rb
View File

@@ -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

160
Data/Scripts/011_Battle/005_AI/053_AI_MoveHandlers_BattlerOther.rb
View File

@@ -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]

316
Data/Scripts/011_Battle/005_AI/054_AI_MoveHandlers_MoveAttributes.rb
View File

@@ -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
score -= 90
elsif user.hp < target.hp / 2
score += 50
end
next score
next score + 50 if user.hp < target.hp / 2
}
)
#===============================================================================
#
#===============================================================================
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

85
Data/Scripts/011_Battle/005_AI/055_AI_MoveHandlers_MultiHit.rb
View File

@@ -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

87
Data/Scripts/011_Battle/005_AI/056_AI_MoveHandlers_Healing.rb
View File

@@ -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

33
Data/Scripts/011_Battle/005_AI/057_AI_MoveHandlers_Items.rb
View File

@@ -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

93
Data/Scripts/011_Battle/005_AI/058_AI_MoveHandlers_ChangeMoveEffect.rb
View File

@@ -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)

99
Data/Scripts/011_Battle/005_AI/059_AI_MoveHandlers_SwitchingActing.rb
View File

@@ -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