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

Refactored AI switching code, added "UsePokemonInOrder" skill flag

Browse Source
This commit is contained in:
Maruno17
2023-02-14 16:40:52 +00:00
parent a8e024eb3e
commit 81d069eef1
16 changed files with 353 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
Data/Scripts/011_Battle/001_Battle/005_Battle_ActionSwitching.rb
View File

@@ -6,7 +6,7 @@ class Battle
# battle.
# NOTE: Messages are only shown while in the party screen when choosing a
# command for the next round.
def pbCanSwitchLax?(idxBattler, idxParty, partyScene = nil)
def pbCanSwitchIn?(idxBattler, idxParty, partyScene = nil)
return true if idxParty < 0
party = pbParty(idxBattler)
return false if idxParty >= party.length
@@ -18,8 +18,7 @@ class Battle
if !pbIsOwner?(idxBattler, idxParty)
if partyScene
owner = pbGetOwnerFromPartyIndex(idxBattler, idxParty)
partyScene.pbDisplay(_INTL("You can't switch {1}'s Pokémon with one of yours!",
owner.name))
partyScene.pbDisplay(_INTL("You can't switch {1}'s Pokémon with one of yours!", owner.name))
end
return false
end
@@ -35,30 +34,15 @@ class Battle
end
# Check whether the currently active Pokémon (at battler index idxBattler) can
# switch out (and that its replacement at party index idxParty can switch in).
# NOTE: Messages are only shown while in the party screen when choosing a
# command for the next round.
def pbCanSwitch?(idxBattler, idxParty = -1, partyScene = nil)
# Check whether party Pokémon can switch in
return false if !pbCanSwitchLax?(idxBattler, idxParty, partyScene)
# Make sure another battler isn't already choosing to switch to the party
# Pokémon
allSameSideBattlers(idxBattler).each do |b|
next if choices[b.index][0] != :SwitchOut || choices[b.index][1] != idxParty
partyScene&.pbDisplay(_INTL("{1} has already been selected.",
pbParty(idxBattler)[idxParty].name))
return false
end
# Check whether battler can switch out
# switch out.
def pbCanSwitchOut?(idxBattler, partyScene = nil)
battler = @battlers[idxBattler]
return true if battler.fainted?
# Ability/item effects that allow switching no matter what
if battler.abilityActive? &&
Battle::AbilityEffects.triggerCertainSwitching(battler.ability, battler, self)
if battler.abilityActive? && Battle::AbilityEffects.triggerCertainSwitching(battler.ability, battler, self)
return true
end
if battler.itemActive? &&
Battle::ItemEffects.triggerCertainSwitching(battler.item, battler, self)
if battler.itemActive? && Battle::ItemEffects.triggerCertainSwitching(battler.item, battler, self)
return true
end
# Other certain switching effects
@@ -72,25 +56,42 @@ class Battle
allOtherSideBattlers(idxBattler).each do |b|
next if !b.abilityActive?
if Battle::AbilityEffects.triggerTrappingByTarget(b.ability, battler, b, self)
partyScene&.pbDisplay(_INTL("{1}'s {2} prevents switching!",
b.pbThis, b.abilityName))
partyScene&.pbDisplay(_INTL("{1}'s {2} prevents switching!", b.pbThis, b.abilityName))
return false
end
end
allOtherSideBattlers(idxBattler).each do |b|
next if !b.itemActive?
if Battle::ItemEffects.triggerTrappingByTarget(b.item, battler, b, self)
partyScene&.pbDisplay(_INTL("{1}'s {2} prevents switching!",
b.pbThis, b.itemName))
partyScene&.pbDisplay(_INTL("{1}'s {2} prevents switching!", b.pbThis, b.itemName))
return false
end
end
return true
end
# Check whether the currently active Pokémon (at battler index idxBattler) can
# switch out (and that its replacement at party index idxParty can switch in).
# NOTE: Messages are only shown while in the party screen when choosing a
# command for the next round.
def pbCanSwitch?(idxBattler, idxParty = -1, partyScene = nil)
# Check whether party Pokémon can switch in
return false if !pbCanSwitchIn?(idxBattler, idxParty, partyScene)
# Make sure another battler isn't already choosing to switch to the party
# Pokémon
allSameSideBattlers(idxBattler).each do |b|
next if choices[b.index][0] != :SwitchOut || choices[b.index][1] != idxParty
partyScene&.pbDisplay(_INTL("{1} has already been selected.",
pbParty(idxBattler)[idxParty].name))
return false
end
# Check whether battler can switch out
return pbCanSwitchOut?(idxBattler, partyScene)
end
def pbCanChooseNonActive?(idxBattler)
pbParty(idxBattler).each_with_index do |_pkmn, i|
return true if pbCanSwitchLax?(idxBattler, i)
return true if pbCanSwitchIn?(idxBattler, i)
end
return false
end
@@ -113,7 +114,7 @@ class Battle
ret = -1
@scene.pbPartyScreen(idxBattler, canCancel) do |idxParty, partyScene|
if checkLaxOnly
next false if !pbCanSwitchLax?(idxBattler, idxParty, partyScene)
next false if !pbCanSwitchIn?(idxBattler, idxParty, partyScene)
elsif !pbCanSwitch?(idxBattler, idxParty, partyScene)
next false
end
@@ -130,7 +131,7 @@ class Battle
# things happening (U-turn, Baton Pass, in def pbEORSwitch).
def pbSwitchInBetween(idxBattler, checkLaxOnly = false, canCancel = false)
return pbPartyScreen(idxBattler, checkLaxOnly, canCancel) if !@controlPlayer && pbOwnedByPlayer?(idxBattler)
return @battleAI.pbDefaultChooseNewEnemy(idxBattler, pbParty(idxBattler))
return @battleAI.pbDefaultChooseNewEnemy(idxBattler)
end
#=============================================================================
@@ -206,7 +207,7 @@ class Battle
if random
choices = [] # Find all Pokémon that can switch in
eachInTeamFromBattlerIndex(idxBattler) do |_pkmn, i|
choices.push(i) if pbCanSwitchLax?(idxBattler, i)
choices.push(i) if pbCanSwitchIn?(idxBattler, i)
end
return -1 if choices.length == 0
return choices[pbRandom(choices.length)]

2
Data/Scripts/011_Battle/001_Battle/009_Battle_CommandPhase.rb
View File

@@ -140,7 +140,7 @@ class Battle
def pbPartyMenu(idxBattler)
ret = -1
if @debug
ret = @battleAI.pbDefaultChooseNewEnemy(idxBattler, pbParty(idxBattler))
ret = @battleAI.pbDefaultChooseNewEnemy(idxBattler)
else
ret = pbPartyScreen(idxBattler, false, true, true)
end

2
Data/Scripts/011_Battle/003_Move/013_MoveEffects_SwitchingActing.rb
View File

@@ -182,7 +182,7 @@ class Battle::Move::SwitchOutTargetStatusMove < Battle::Move
if @battle.trainerBattle?
canSwitch = false
@battle.eachInTeamFromBattlerIndex(target.index) do |_pkmn, i|
next if !@battle.pbCanSwitchLax?(target.index, i)
next if !@battle.pbCanSwitchIn?(target.index, i)
canSwitch = true
break
end

48
Data/Scripts/011_Battle/005_AI/001_Battle_AI.rb
View File

@@ -51,14 +51,33 @@ class Battle::AI
# Choose an action.
def pbDefaultChooseEnemyCommand(idxBattler)
set_up(idxBattler)
return if pbEnemyShouldWithdraw?
return if pbEnemyShouldUseItem?
return if @battle.pbAutoFightMenu(idxBattler)
ret = false
PBDebug.logonerr { ret = pbChooseToSwitchOut }
if ret
PBDebug.log("")
return
end
if pbEnemyShouldUseItem?
PBDebug.log("")
return
end
if @battle.pbAutoFightMenu(idxBattler)
PBDebug.log("")
return
end
@battle.pbRegisterMegaEvolution(idxBattler) if pbEnemyShouldMegaEvolve?
choices = pbGetMoveScores
pbChooseMove(choices)
PBDebug.log("")
end
# Choose a replacement Pokémon (called directly from @battle, not part of
# action choosing). Must return the party index of a replacement Pokémon if
# possible.
def pbDefaultChooseNewEnemy(idxBattler)
set_up(idxBattler)
return choose_best_replacement_pokemon(idxBattler, true)
end
end
#===============================================================================
@@ -72,12 +91,14 @@ module Battle::AI::Handlers
MoveBasePower = HandlerHash.new
GeneralMoveScore = HandlerHash.new
GeneralMoveAgainstTargetScore = HandlerHash.new
# Move type - uses main battle code via rough_type
# Move accuracy - uses main battle code via rough_accuracy
# Move target
# Move additional effect chance
# Move unselectable check
# Move failure check
# TODO: Make HandlerHashes for these?
# Move type - uses main battle code via rough_type
# Move accuracy - uses main battle code via rough_accuracy
# Move target
# Move additional effect chance
# Move unselectable check
# Move failure check
ShouldSwitch = HandlerHash.new
def self.move_will_fail?(function_code, *args)
return MoveFailureCheck.trigger(function_code, *args) || false
@@ -117,4 +138,13 @@ module Battle::AI::Handlers
end
return score
end
def self.should_switch?(*args)
ret = false
ShouldSwitch.each do |id, switch_proc|
ret ||= switch_proc.call(*args)
break if ret
end
return ret
end
end

406
Data/Scripts/011_Battle/005_AI/003_AI_Switch.rb
View File

@@ -2,184 +2,268 @@ class Battle::AI
#=============================================================================
# Decide whether the opponent should switch Pokémon
#=============================================================================
def pbEnemyShouldWithdraw?
ret = false
PBDebug.logonerr { ret = pbEnemyShouldWithdrawEx?(false) }
return ret
end
def pbEnemyShouldWithdrawEx?(forceSwitch)
# Called by the AI's def pbDefaultChooseEnemyCommand, and by def pbChooseMove
# if the only moves known are bad ones (the latter forces a switch). Also
# aliased by the Battle Palace and Battle Arena.
def pbChooseToSwitchOut(force_switch = false)
return false if @user.wild?
shouldSwitch = forceSwitch
battler = @user.battler
batonPass = -1
foe = nil
moveType = nil
# If Pokémon is within 6 levels of the foe, and foe's last move was
# super-effective and powerful
if !shouldSwitch && battler.turnCount > 0 && @trainer.high_skill?
target = battler.pbDirectOpposing(true)
foe = @battlers[target.index]
if !target.fainted? && target.lastMoveUsed &&
(target.level - battler.level).abs <= 6
moveData = GameData::Move.get(target.lastMoveUsed)
moveType = moveData.type
typeMod = @user.effectiveness_of_type_against_battler(moveType, foe)
if Effectiveness.super_effective?(typeMod) && moveData.power > 50
switchChance = (moveData.power > 70) ? 30 : 20
shouldSwitch = (pbAIRandom(100) < switchChance)
end
end
end
# Pokémon can't do anything (must have been in battle for at least 5 rounds)
if !shouldSwitch && !@battle.pbCanChooseAnyMove?(battler.index) &&
battler.turnCount && battler.turnCount >= 5
shouldSwitch = true
end
# Pokémon is about to faint because of Perish Song
if !shouldSwitch && battler.effects[PBEffects::PerishSong] == 1
shouldSwitch = true
end
# Pokémon is Perish Songed and has Baton Pass
if @trainer.high_skill? && battler.effects[PBEffects::PerishSong] == 1
battler.eachMoveWithIndex do |m, i|
next if m.function != "SwitchOutUserPassOnEffects" # Baton Pass
next if !@battle.pbCanChooseMove?(battler.index, i, false)
batonPass = i
return false if !@battle.pbCanSwitchOut?(@user.index)
# Don't switch if there is a single foe and it is resting after Hyper Beam
# or will Truant (i.e. free turn)
if @trainer.high_skill?
foe_can_act = false
each_foe_battler(@user.side) do |b|
next if !b.can_attack?
foe_can_act = true
break
end
return false if !foe_can_act
end
# Pokémon will faint because of bad poisoning at the end of this round, but
# would survive at least one more round if it were regular poisoning instead
if !shouldSwitch && battler.status == :POISON && battler.statusCount > 0 && @trainer.high_skill?
toxicHP = battler.totalhp / 16
nextToxicHP = toxicHP * (battler.effects[PBEffects::Toxic] + 1)
if battler.hp <= nextToxicHP && battler.hp > toxicHP * 2
shouldSwitch = true if pbAIRandom(100) < 80
end
# Various calculations to decide whether to switch
if force_switch
PBDebug.log_ai("#{@user.name} is being forced to switch out")
else
should_switch = Battle::AI::Handlers.should_switch?(@user, self, @battle)
return false if !should_switch
end
# Pokémon is Encored into an unfavourable move
if !shouldSwitch && battler.effects[PBEffects::Encore] > 0 && @trainer.medium_skill?
idxEncoredMove = battler.pbEncoredMoveIndex
if idxEncoredMove >= 0
scoreSum = 0
scoreCount = 0
battler.allOpposing.each do |b|
set_up_move_check(battler.moves[idxEncoredMove])
scoreSum += pbGetMoveScore([b])
scoreCount += 1
end
if scoreCount > 0 && scoreSum / scoreCount <= 20
shouldSwitch = true if pbAIRandom(100) < 80
end
end
# Want to switch; find the best replacement Pokémon
idxParty = choose_best_replacement_pokemon(@user.index, force_switch)
if idxParty < 0 # No good replacement Pokémon found
PBDebug.log(" => no good replacement Pokémon, will not switch after all")
return false
end
# If there is a single foe and it is resting after Hyper Beam or is
# Truanting (i.e. free turn)
if shouldSwitch && @battle.pbSideSize(battler.index + 1) == 1 &&
!battler.pbDirectOpposing.fainted? && @trainer.high_skill?
opp = battler.pbDirectOpposing
if (opp.effects[PBEffects::HyperBeam] > 0 ||
(opp.hasActiveAbility?(:TRUANT) && opp.effects[PBEffects::Truant]))
shouldSwitch = false if pbAIRandom(100) < 80
end
# Prefer using Baton Pass instead of switching
baton_pass = -1
@user.battler.eachMoveWithIndex do |m, i|
next if m.function != "SwitchOutUserPassOnEffects" # Baton Pass
next if !@battle.pbCanChooseMove?(@user.index, i, false)
baton_pass = i
break
end
# Sudden Death rule - I'm not sure what this means
if !shouldSwitch && @battle.rules["suddendeath"] && battler.turnCount > 0
if battler.hp <= battler.totalhp / 4 && pbAIRandom(100) < 30
shouldSwitch = true
elsif battler.hp <= battler.totalhp / 2 && pbAIRandom(100) < 80
shouldSwitch = true
end
end
if shouldSwitch
list = []
idxPartyStart, idxPartyEnd = @battle.pbTeamIndexRangeFromBattlerIndex(battler.index)
@battle.pbParty(battler.index).each_with_index do |pkmn, i|
next if @trainer.has_skill_flag?("ReserveLastPokemon") && i == idxPartyEnd - 1 # Don't choose to switch in ace
next if !@battle.pbCanSwitch?(battler.index, i)
# If perish count is 1, it may be worth it to switch
# even with Spikes, since Perish Song's effect will end
if battler.effects[PBEffects::PerishSong] != 1
# Will contain effects that recommend against switching
spikes = battler.pbOwnSide.effects[PBEffects::Spikes]
# Don't switch to this if too little HP
if spikes > 0
spikesDmg = [8, 6, 4][spikes - 1]
next if pkmn.hp <= pkmn.totalhp / spikesDmg &&
!pkmn.hasType?(:FLYING) && !pkmn.hasAbility?(:LEVITATE)
end
end
# moveType is the type of the target's last used move
if moveType && Effectiveness.ineffective?(@user.effectiveness_of_type_against_battler(moveType, foe))
weight = 65
typeMod = pbCalcTypeModPokemon(pkmn, battler.pbDirectOpposing(true))
if Effectiveness.super_effective?(typeMod)
# Greater weight if new Pokemon's type is effective against target
weight = 85
end
list.unshift(i) if pbAIRandom(100) < weight # Put this Pokemon first
elsif moveType && Effectiveness.resistant?(@user.effectiveness_of_type_against_battler(moveType, foe))
weight = 40
typeMod = pbCalcTypeModPokemon(pkmn, battler.pbDirectOpposing(true))
if Effectiveness.super_effective?(typeMod)
# Greater weight if new Pokemon's type is effective against target
weight = 60
end
list.unshift(i) if pbAIRandom(100) < weight # Put this Pokemon first
else
list.push(i) # put this Pokemon last
end
end
if list.length > 0
if batonPass >= 0 && @battle.pbRegisterMove(battler.index, batonPass, false)
PBDebug.log_ai("#{@user.name} will use Baton Pass to avoid Perish Song")
return true
end
if @battle.pbRegisterSwitch(battler.index, list[0])
PBDebug.log_ai("#{@user.name} will switch with #{@battle.pbParty(battler.index)[list[0]].name}")
return true
end
end
if baton_pass >= 0 && @battle.pbRegisterMove(@user.index, baton_pass, false)
PBDebug.log(" => will use Baton Pass to switch out")
return true
elsif @battle.pbRegisterSwitch(@user.index, idxParty)
PBDebug.log(" => will switch with #{@battle.pbParty(@user.index)[idxParty].name}")
return true
end
return false
end
# Choose a replacement Pokémon (called directly from @battle, not part of
# action choosing).
def pbDefaultChooseNewEnemy(idxBattler, party)
set_up(idxBattler)
enemies = []
#=============================================================================
def choose_best_replacement_pokemon(idxBattler, mandatory = false)
# Get all possible replacement Pokémon
party = @battle.pbParty(idxBattler)
idxPartyStart, idxPartyEnd = @battle.pbTeamIndexRangeFromBattlerIndex(idxBattler)
party.each_with_index do |_p, i|
if @trainer.has_skill_flag?("ReserveLastPokemon")
next if i == idxPartyEnd - 1 && enemies.length > 0 # Ignore ace if possible
reserves = []
party.each_with_index do |_pkmn, i|
next if !@battle.pbCanSwitchIn?(idxBattler, i)
if !mandatory
ally_will_switch_with_i = false
@battle.allSameSideBattlers(idxBattler).each do |b|
next if @battle.choices[b.index][0] != :SwitchOut || @battle.choices[b.index][1] != i
ally_will_switch_with_i = true
break
end
next if ally_will_switch_with_i
end
enemies.push(i) if @battle.pbCanSwitchLax?(idxBattler, i)
# Ignore ace if possible
if @trainer.has_skill_flag?("ReserveLastPokemon") && i == idxPartyEnd - 1
next if !mandatory || reserves.length > 0
end
reserves.push([i, 100])
break if @trainer.has_skill_flag?("UsePokemonInOrder") && reserves.length > 0
end
return -1 if enemies.length == 0
return pbChooseBestNewEnemy(idxBattler, party, enemies)
return -1 if reserves.length == 0
# Rate each possible replacement Pokémon
reserves.each_with_index do |reserve, i|
reserves[i][1] = rate_replacement_pokemon(idxBattler, party[reserve[0]], reserve[1])
end
reserves.sort! { |a, b| b[1] <=> a[1] } # Sort from highest to lowest rated
# Don't bother choosing to switch if all replacements are poorly rated
if !mandatory
# TODO: Should the current battler be rated as well, to provide a
# threshold instead of using a threshold of 100?
return -1 if reserves[0][1] < 100 # Best replacement rated at <100, don't switch
end
# Return the best rated replacement Pokémon
return reserves[0][0]
end
def pbChooseBestNewEnemy(idxBattler, party, enemies)
return -1 if !enemies || enemies.length == 0
best = -1
bestSum = 0
enemies.each do |i|
pkmn = party[i]
sum = 0
pkmn.moves.each do |m|
next if m.power == 0
@battle.battlers[idxBattler].allOpposing.each do |b|
bTypes = b.pbTypes(true)
sum += Effectiveness.calculate(m.type, *bTypes)
end
end
if best == -1 || sum > bestSum
best = i
bestSum = sum
def rate_replacement_pokemon(idxBattler, pkmn, score)
battler_side = @battle.sides[idxBattler & 1]
pkmn_types = pkmn.types
entry_hazard_damage = 0
# Stealth Rock
if battler_side.effects[PBEffects::StealthRock] && !pkmn.hasAbility?(:MAGICGUARD) &&
GameData::Type.exists?(:ROCK) && !pkmn.hasItem?(:HEAVYDUTYBOOTS)
eff = Effectiveness.calculate(:ROCK, *pkmn_types)
if !Effectiveness.ineffective?(eff)
entry_hazard_damage += pkmn.totalhp * eff / 8
end
end
return best
# Spikes
if battler_side.effects[PBEffects::Spikes] > 0 && !pkmn.hasAbility?(:MAGICGUARD) &&
!battler.airborne? && !pkmn.hasItem?(:HEAVYDUTYBOOTS)
if @battle.field.effects[PBEffects::Gravity] > 0 || pkmn.hasItem?(:IRONBALL) ||
!(pkmn.hasType?(:FLYING) || pkmn.hasItem?(:LEVITATE) || pkmn.hasItem?(:AIRBALLOON))
spikes_div = [8, 6, 4][battler_side.effects[PBEffects::Spikes] - 1]
entry_hazard_damage += pkmn.totalhp / spikes_div
end
end
if entry_hazard_damage >= pkmn.hp
score -= 50 # pkmn will just faint
elsif entry_hazard_damage > 0
score -= 50 * entry_hazard_damage / pkmn.hp
end
# TODO: Toxic Spikes.
# TODO: Sticky Web.
# Predict effectiveness of foe's last used move against pkmn
each_foe_battler(@user.side) do |b, i|
next if !b.battler.lastMoveUsed
move_data = GameData::Move.get(b.battler.lastMoveUsed)
next if move_data.status?
move_type = move_data.type
eff = Effectiveness.calculate(move_type, *pkmn_types)
score -= move_data.power * eff / 5
end
# Add power * effectiveness / 10 of all moves to score
pkmn.moves.each do |m|
next if m.power == 0 || (m.pp == 0 && m.total_pp > 0)
@battle.battlers[idxBattler].allOpposing.each do |b|
bTypes = b.pbTypes(true)
score += m.power * Effectiveness.calculate(m.type, *bTypes) / 10
end
end
# Prefer if user is about to faint from Perish Song
score += 10 if @user.effects[PBEffects::PerishSong] == 1
return score
end
end
#===============================================================================
# If Pokémon is within 5 levels of the foe, and foe's last move was
# super-effective and powerful.
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:high_damage_from_foe,
proc { |battler, ai, battle|
if battler.turnCount > 0 && battler.hp < battler.totalhp / 2 && ai.trainer.high_skill?
target_battler = battler.battler.pbDirectOpposing(true)
foe = ai.battlers[target_battler.index]
if !foe.fainted? && foe.battler.lastMoveUsed && (foe.level - battler.level).abs <= 5
move_data = GameData::Move.get(foe.battler.lastMoveUsed)
eff = battler.effectiveness_of_type_against_battler(move_data.type, foe)
if Effectiveness.super_effective?(eff) && move_data.power > 70
switch_chance = (move_data.power > 95) ? 40 : 20
if ai.pbAIRandom(100) < switch_chance
PBDebug.log_ai("#{battler.name} wants to switch because a foe can do a lot of damage to it")
next true
end
end
end
end
next false
}
)
#===============================================================================
# Pokémon can't do anything (must have been in battle for at least 5 rounds).
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:battler_is_useless,
proc { |battler, ai, battle|
if !battle.pbCanChooseAnyMove?(battler.index) && battler.turnCount >= 5
PBDebug.log_ai("#{battler.name} wants to switch because it can't do anything")
next true
end
next false
}
)
#===============================================================================
# Pokémon is Perish Songed and has Baton Pass.
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:perish_song,
proc { |battler, ai, battle|
if battler.effects[PBEffects::PerishSong] == 1
PBDebug.log_ai("#{battler.name} wants to switch because it is about to faint from Perish Song")
next true
end
next false
}
)
#===============================================================================
# Pokémon will faint because of bad poisoning at the end of this round, but
# would survive at least one more round if it were regular poisoning instead.
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:reduce_toxic_to_regular_poisoning,
proc { |battler, ai, battle|
if battler.status == :POISON && battler.statusCount > 0 && ai.trainer.high_skill?
next false if battler.has_active_ability?(:POISONHEAL)
next false if !battler.battler.takesIndirectDamage?
poison_damage = battler.totalhp / 8
next_toxic_damage = battler.totalhp * (battler.effects[PBEffects::Toxic] + 1) / 16
if battler.hp <= next_toxic_damage && battler.hp > poison_damage
if ai.pbAIRandom(100) < 80
PBDebug.log_ai("#{battler.name} wants to switch to reduce toxic to regular poisoning")
next true
end
end
end
next false
}
)
#===============================================================================
# Pokémon is Encored into an unfavourable move.
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:bad_encored_move,
proc { |battler, ai, battle|
if battler.effects[PBEffects::Encore] > 0 && ai.trainer.medium_skill?
idxEncoredMove = battler.battler.pbEncoredMoveIndex
if idxEncoredMove >= 0
ai.set_up_move_check(battler.moves[idxEncoredMove])
scoreSum = 0
scoreCount = 0
battler.battler.allOpposing.each do |b|
scoreSum += ai.pbGetMoveScore([b])
scoreCount += 1
end
if scoreCount > 0 && scoreSum / scoreCount <= 20
if ai.pbAIRandom(100) < 80
PBDebug.log_ai("#{battler.name} wants to switch because of encoring a bad move")
next true
else
next false
end
end
end
end
next false
}
)
#===============================================================================
# Sudden Death rule - I'm not sure what this means.
# TODO: Review switch deciding.
#===============================================================================
Battle::AI::Handlers::ShouldSwitch.add(:sudden_death,
proc { |battler, ai, battle|
if battle.rules["suddendeath"] && battler.turnCount > 0
if battler.hp <= battler.totalhp / 4 && ai.pbAIRandom(100) < 30
PBDebug.log_ai("#{battler.name} wants to switch because of the sudden death rule")
next true
elsif battler.hp <= battler.totalhp / 2 && ai.pbAIRandom(100) < 80
PBDebug.log_ai("#{battler.name} wants to switch because of the sudden death rule")
next true
end
end
next false
}
)

2
Data/Scripts/011_Battle/005_AI/004_AI_ChooseMove.rb
View File

@@ -313,7 +313,7 @@ class Battle::AI
end
if badMoves
PBDebug.log_ai("#{@user.name} wants to switch due to terrible moves")
return if pbEnemyShouldWithdrawEx?(true)
return if pbChooseToSwitchOut(true)
PBDebug.log_ai("#{@user.name} won't switch after all")
end
end

2
Data/Scripts/011_Battle/005_AI/070_AI_MoveHandlers_GeneralModifiers.rb
View File

@@ -173,7 +173,7 @@ Battle::AI::Handlers::GeneralMoveAgainstTargetScore.add(:flinching_effects,
#===============================================================================
# TODO: Don't prefer contact move if making contact with the target could
# trigger an effect that's bad for the user (Static, etc.).
# => Also check if target has previously used Spiky Shield.King's Shield/
# => Also check if target has previously used Spiky Shield/King's Shield/
# Baneful Bunker, and don't prefer move if so
#===============================================================================

8
Data/Scripts/011_Battle/005_AI/101_AITrainer.rb
View File

@@ -14,6 +14,7 @@
# ScoreMoves
# PreferMultiTargetMoves
# ReserveLastPokemon (don't switch it in if possible)
# UsePokemonInOrder (uses earliest-listed Pokémon possible)
#===============================================================================
class Battle::AI::AITrainer
attr_reader :side, :trainer_index
@@ -37,7 +38,9 @@ class Battle::AI::AITrainer
@skill_flags.push("ScoreMoves")
@skill_flags.push("PreferMultiTargetMoves")
end
if @skill >= 100
if !medium_skill?
@skill_flags.push("UsePokemonInOrder")
elsif best_skill?
# TODO: Also have flag "DontReserveLastPokemon" which negates this.
@skill_flags.push("ReserveLastPokemon")
end
@@ -47,17 +50,14 @@ class Battle::AI::AITrainer
return @skill_flags.include?(flag)
end
# TODO: This will eventually be replaced by something else, maybe skill flags.
def medium_skill?
return @skill >= 32
end
# TODO: This will eventually be replaced by something else, maybe skill flags.
def high_skill?
return @skill >= 48
end
# TODO: This will eventually be replaced by something else, maybe skill flags.
def best_skill?
return @skill >= 100
end

3
Data/Scripts/011_Battle/005_AI/102_AIBattler.rb
View File

@@ -35,6 +35,7 @@ class Battle::AI::AIBattler
def stages; return @battler.stages; end
def statStageAtMax?(stat); return @battler.statStageAtMax?(stat); end
def statStageAtMin?(stat); return @battler.statStageAtMin?(stat); end
def moves; return @battler.moves; end
def wild?
return @ai.battle.wildBattle? && opposes?
@@ -300,7 +301,7 @@ class Battle::AI::AIBattler
def can_switch_lax?
return false if wild?
@ai.battle.eachInTeamFromBattlerIndex(@index) do |pkmn, i|
return true if @ai.battle.pbCanSwitchLax?(@index, i)
return true if @ai.battle.pbCanSwitchIn?(@index, i)
end
return false
end

20
Data/Scripts/011_Battle/005b_AI move function codes/054_AI_MoveHandlers_MoveAttributes.rb
View File

@@ -431,6 +431,8 @@ Battle::AI::Handlers::MoveEffectScore.add("EnsureNextCriticalHit",
next Battle::AI::MOVE_USELESS_SCORE if user.effects[PBEffects::LaserFocus] > 0
# Useless if the user's critical hit stage ensures critical hits already, or
# critical hits are impossible (e.g. via Lucky Chant)
# TODO: Critical hit rate is calculated using a target, but this move
# doesn't have a target. An error is shown when trying it.
crit_stage = move.rough_critical_hit_stage
if crit_stage < 0 ||
crit_stage >= Battle::Move::CRITICAL_HIT_RATIOS.length ||
@@ -491,7 +493,7 @@ Battle::AI::Handlers::MoveEffectScore.add("StartPreventCriticalHitsAgainstUserSi
next if crit_stage < 0
end
crit_stage += b.effects[PBEffects::FocusEnergy]
crit_stage += 1 if m.check_for_move { |m| m.highCriticalRate? }
crit_stage += 1 if b.check_for_move { |m| m.highCriticalRate? }
crit_stage = [crit_stage, Battle::Move::CRITICAL_HIT_RATIOS.length - 1].min
crit_stage = 3 if crit_stage < 3 && m.check_for_move { |m| m.pbCritialOverride(b.battler, user.battler) > 0 }
# TODO: Change the score depending on how much of an effect a critical hit
@@ -750,7 +752,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUser",
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -801,7 +803,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserBanefulBunker",
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -852,7 +854,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesKingsShie
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -902,7 +904,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromDamagingMovesObstruct"
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -951,7 +953,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserFromTargetingMovesSpikyShi
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -1086,7 +1088,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserSideFromPriorityMoves",
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)
@@ -1105,7 +1107,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserSideFromMultiTargetDamagin
next Battle::AI::MOVE_USELESS_SCORE if user.effects[PBEffects::ProtectRate] >= 4
# Score changes for each foe
useless = true
ai.each_battler(user.side) do |b, i|
ai.each_battler do |b, i|
next if b.index == user.index || !b.can_attack?
next if !b.check_for_move { |m| (Settings::MECHANICS_GENERATION >= 7 || move.damagingMove?) &&
m.pbTarget(b.battler).num_targets > 1 }
@@ -1132,7 +1134,7 @@ Battle::AI::Handlers::MoveEffectScore.add("ProtectUserSideFromMultiTargetDamagin
end
# Don't prefer if the user used a protection move last turn, making this one
# less likely to work
score -= (user.effects[PBEffects::ProtectRate] - 1) * (Settings::MECHANICS_GENERATION >= 6) ? 12 : 8
score -= (user.effects[PBEffects::ProtectRate] - 1) * ((Settings::MECHANICS_GENERATION >= 6) ? 12 : 8)
next score
}
)

6
Data/Scripts/011_Battle/005b_AI move function codes/055_AI_MoveHandlers_MultiHit.rb
View File

@@ -366,7 +366,7 @@ Battle::AI::Handlers::MoveEffectAgainstTargetScore.add("TwoTurnAttackInvulnerabl
score = Battle::AI::Handlers.apply_move_effect_against_target_score("TwoTurnAttack",
score, move, user, target, ai, battle)
# Score for being semi-invulnerable underground
user.each_foe_battler(user.side) do |b, i|
ai.each_foe_battler(user.side) do |b, i|
if b.check_for_move { |m| m.hitsDiggingTargets? }
score -= 8
else
@@ -386,7 +386,7 @@ Battle::AI::Handlers::MoveEffectAgainstTargetScore.add("TwoTurnAttackInvulnerabl
score = Battle::AI::Handlers.apply_move_effect_against_target_score("TwoTurnAttack",
score, move, user, target, ai, battle)
# Score for being semi-invulnerable underwater
user.each_foe_battler(user.side) do |b, i|
ai.each_foe_battler(user.side) do |b, i|
if b.check_for_move { |m| m.hitsDivingTargets? }
score -= 8
else
@@ -406,7 +406,7 @@ Battle::AI::Handlers::MoveEffectAgainstTargetScore.add("TwoTurnAttackInvulnerabl
score = Battle::AI::Handlers.apply_move_effect_against_target_score("TwoTurnAttack",
score, move, user, target, ai, battle)
# Score for being semi-invulnerable in the sky
user.each_foe_battler(user.side) do |b, i|
ai.each_foe_battler(user.side) do |b, i|
if b.check_for_move { |m| m.hitsFlyingTargets? }
score -= 8
else

6
Data/Scripts/011_Battle/005b_AI move function codes/059_AI_MoveHandlers_SwitchingActing.rb
View File

@@ -116,7 +116,7 @@ Battle::AI::Handlers::MoveFailureAgainstTargetCheck.add("SwitchOutTargetStatusMo
if battle.trainerBattle?
will_fail = true
battle.eachInTeamFromBattlerIndex(target.index) do |_pkmn, i|
next if !battle.pbCanSwitchLax?(target.index, i)
next if !battle.pbCanSwitchIn?(target.index, i)
will_fail = false
break
end
@@ -315,8 +315,8 @@ Battle::AI::Handlers::MoveEffectScore.add("UsedAfterAllyRoundWithDoublePower",
#===============================================================================
#
#===============================================================================
Battle::AI::Handlers::MoveEffectScore.add("TargetActsNext",
proc { |score, move, user, ai, battle|
Battle::AI::Handlers::MoveEffectAgainstTargetScore.add("TargetActsNext",
proc { |score, move, user, target, ai, battle|
# Useless if the target is a foe
next Battle::AI::MOVE_USELESS_SCORE if target.opposes?(user)
# Compare the speeds of all battlers

2
Data/Scripts/011_Battle/006_Other battle code/008_Battle_AbilityEffects.rb
View File

@@ -381,7 +381,7 @@ Battle::AbilityEffects::OnHPDroppedBelowHalf.add(:EMERGENCYEXIT,
end
# In trainer battles
next false if battle.pbAllFainted?(battler.idxOpposingSide)
next false if !battle.pbCanSwitch?(battler.index) # Battler can't switch out
next false if !battle.pbCanSwitchOut?(battler.index) # Battler can't switch out
next false if !battle.pbCanChooseNonActive?(battler.index) # No Pokémon can switch in
battle.pbShowAbilitySplash(battler, true)
battle.pbHideAbilitySplash(battler)

2
Data/Scripts/011_Battle/006_Other battle code/009_Battle_ItemEffects.rb
View File

@@ -451,7 +451,7 @@ Battle::ItemEffects::OnStatLoss.add(:EJECTPACK,
battler.inTwoTurnAttack?("TwoTurnAttackInvulnerableInSkyTargetCannotAct") # Sky Drop
next false if battle.pbAllFainted?(battler.idxOpposingSide)
next false if battler.wild? # Wild Pokémon can't eject
next false if !battle.pbCanSwitch?(battler.index) # Battler can't switch out
next false if !battle.pbCanSwitchOut?(battler.index) # Battler can't switch out
next false if !battle.pbCanChooseNonActive?(battler.index) # No Pokémon can switch in
battle.pbCommonAnimation("UseItem", battler)
battle.pbDisplay(_INTL("{1} is switched out by the {2}!", battler.pbThis, battler.itemName))

8
Data/Scripts/011_Battle/007_Other battle types/003_BattlePalaceBattle.rb
View File

@@ -177,12 +177,12 @@ class Battle::AI
@justswitched = [false, false, false, false]
end
unless method_defined?(:_battlePalace_pbEnemyShouldWithdraw?)
alias _battlePalace_pbEnemyShouldWithdraw? pbEnemyShouldWithdraw?
unless method_defined?(:_battlePalace_pbChooseToSwitchOut)
alias _battlePalace_pbChooseToSwitchOut pbChooseToSwitchOut
end
def pbEnemyShouldWithdraw?
return _battlePalace_pbEnemyShouldWithdraw? if !@battlePalace
def pbChooseToSwitchOut(force_switch = false)
return _battlePalace_pbChooseToSwitchOut(force_switch) if !@battlePalace
thispkmn = @user
idxBattler = @user.index
shouldswitch = false

10
Data/Scripts/011_Battle/007_Other battle types/004_BattleArenaBattle.rb
View File

@@ -50,7 +50,7 @@ class BattleArenaBattle < Battle
@battleAI.battleArena = true
end
def pbCanSwitchLax?(idxBattler, _idxParty, partyScene = nil)
def pbCanSwitchIn?(idxBattler, _idxParty, partyScene = nil)
partyScene&.pbDisplay(_INTL("{1} can't be switched out!", @battlers[idxBattler].pbThis))
return false
end
@@ -207,12 +207,12 @@ end
class Battle::AI
attr_accessor :battleArena
unless method_defined?(:_battleArena_pbEnemyShouldWithdraw?)
alias _battleArena_pbEnemyShouldWithdraw? pbEnemyShouldWithdraw?
unless method_defined?(:_battleArena_pbChooseToSwitchOut)
alias _battleArena_pbChooseToSwitchOut pbChooseToSwitchOut
end
def pbEnemyShouldWithdraw?
return _battleArena_pbEnemyShouldWithdraw? if !@battleArena
def pbChooseToSwitchOut(force_switch = false)
return _battleArena_pbChooseToSwitchOut(force_switch) if !@battleArena
return false
end
end