mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-06 06:01:46 +00:00
292 lines
12 KiB
Ruby
292 lines
12 KiB
Ruby
class PokeBattle_AI
|
|
#=============================================================================
|
|
# Main move-choosing method (moves with higher scores are more likely to be
|
|
# chosen)
|
|
#=============================================================================
|
|
def pbChooseMoves(idxBattler)
|
|
user = @battle.battlers[idxBattler]
|
|
wildBattler = (@battle.wildBattle? && @battle.opposes?(idxBattler))
|
|
skill = 0
|
|
if !wildBattler
|
|
skill = @battle.pbGetOwnerFromBattlerIndex(user.index).skill_level || 0
|
|
end
|
|
# Get scores and targets for each move
|
|
# NOTE: A move is only added to the choices array if it has a non-zero
|
|
# score.
|
|
choices = []
|
|
user.eachMoveWithIndex do |_m,i|
|
|
next if !@battle.pbCanChooseMove?(idxBattler,i,false)
|
|
if wildBattler
|
|
pbRegisterMoveWild(user,i,choices)
|
|
else
|
|
pbRegisterMoveTrainer(user,i,choices,skill)
|
|
end
|
|
end
|
|
# 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]
|
|
end
|
|
# Log the available choices
|
|
if $INTERNAL
|
|
logMsg = "[AI] Move choices for #{user.pbThis(true)} (#{user.index}): "
|
|
choices.each_with_index do |c,i|
|
|
logMsg += "#{user.moves[c[0]].name}=#{c[1]}"
|
|
logMsg += " (target #{c[2]})" if c[2]>=0
|
|
logMsg += ", " if i<choices.length-1
|
|
end
|
|
PBDebug.log(logMsg)
|
|
end
|
|
# Find any preferred moves and just choose from them
|
|
if !wildBattler && skill>=PBTrainerAI.highSkill && 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.pbThis} (#{user.index}) prefers #{user.moves[m[0]].name}")
|
|
@battle.pbRegisterMove(idxBattler,m[0],false)
|
|
@battle.pbRegisterTarget(idxBattler,m[2]) if m[2]>=0
|
|
return
|
|
end
|
|
end
|
|
end
|
|
# Decide whether all choices are bad, and if so, try switching instead
|
|
if !wildBattler && skill>=PBTrainerAI.highSkill
|
|
badMoves = false
|
|
if (maxScore<=20 && user.turnCount>2) ||
|
|
(maxScore<=40 && user.turnCount>5)
|
|
badMoves = true if pbAIRandom(100)<80
|
|
end
|
|
if !badMoves && totalScore<100 && user.turnCount>1
|
|
badMoves = true
|
|
choices.each do |c|
|
|
next if !user.moves[c[0]].damagingMove?
|
|
badMoves = false
|
|
break
|
|
end
|
|
badMoves = false if badMoves && pbAIRandom(100)<10
|
|
end
|
|
if badMoves && pbEnemyShouldWithdrawEx?(idxBattler,true)
|
|
if $INTERNAL
|
|
PBDebug.log("[AI] #{user.pbThis} (#{user.index}) will switch due to terrible moves")
|
|
end
|
|
return
|
|
end
|
|
end
|
|
# If there are no calculated choices, pick one at random
|
|
if choices.length==0
|
|
PBDebug.log("[AI] #{user.pbThis} (#{user.index}) doesn't want to use any moves; picking one at random")
|
|
user.eachMoveWithIndex do |_m,i|
|
|
next if !@battle.pbCanChooseMove?(idxBattler,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.index)
|
|
end
|
|
end
|
|
# Randomly choose a move from the choices and register it
|
|
randNum = pbAIRandom(totalScore)
|
|
choices.each do |c|
|
|
randNum -= c[1]
|
|
next if randNum>=0
|
|
@battle.pbRegisterMove(idxBattler,c[0],false)
|
|
@battle.pbRegisterTarget(idxBattler,c[2]) if c[2]>=0
|
|
break
|
|
end
|
|
# Log the result
|
|
if @battle.choices[idxBattler][2]
|
|
PBDebug.log("[AI] #{user.pbThis} (#{user.index}) will use #{@battle.choices[idxBattler][2].name}")
|
|
end
|
|
end
|
|
|
|
#=============================================================================
|
|
# Get scores for the given move against each possible target
|
|
#=============================================================================
|
|
# Wild Pokémon choose their moves randomly.
|
|
def pbRegisterMoveWild(_user,idxMove,choices)
|
|
choices.push([idxMove,100,-1]) # Move index, score, target
|
|
end
|
|
|
|
# Trainer Pokémon calculate how much they want to use each of their moves.
|
|
def pbRegisterMoveTrainer(user,idxMove,choices,skill)
|
|
move = user.moves[idxMove]
|
|
target_data = move.pbTarget(user)
|
|
if target_data.num_targets > 1
|
|
# If move affects multiple battlers and you don't choose a particular one
|
|
totalScore = 0
|
|
@battle.eachBattler do |b|
|
|
next if !@battle.pbMoveCanTarget?(user.index,b.index,target_data)
|
|
score = pbGetMoveScore(move,user,b,skill)
|
|
totalScore += ((user.opposes?(b)) ? score : -score)
|
|
end
|
|
choices.push([idxMove,totalScore,-1]) if totalScore>0
|
|
elsif target_data.num_targets == 0
|
|
# If move has no targets, affects the user, a side or the whole field
|
|
score = pbGetMoveScore(move,user,user,skill)
|
|
choices.push([idxMove,score,-1]) if score>0
|
|
else
|
|
# If move affects one battler and you have to choose which one
|
|
scoresAndTargets = []
|
|
@battle.eachBattler do |b|
|
|
next if !@battle.pbMoveCanTarget?(user.index,b.index,target_data)
|
|
next if target_data.targets_foe && !user.opposes?(b)
|
|
score = pbGetMoveScore(move,user,b,skill)
|
|
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]])
|
|
end
|
|
end
|
|
end
|
|
|
|
#=============================================================================
|
|
# Get a score for the given move being used against the given target
|
|
#=============================================================================
|
|
def pbGetMoveScore(move,user,target,skill=100)
|
|
skill = PBTrainerAI.minimumSkill if skill<PBTrainerAI.minimumSkill
|
|
score = 100
|
|
score = pbGetMoveScoreFunctionCode(score,move,user,target,skill)
|
|
# A score of 0 here means it absolutely should not be used
|
|
return 0 if score<=0
|
|
if skill>=PBTrainerAI.mediumSkill
|
|
# Prefer damaging moves if AI has no more Pokémon or AI is less clever
|
|
if @battle.pbAbleNonActiveCount(user.idxOwnSide)==0
|
|
if !(skill>=PBTrainerAI.highSkill && @battle.pbAbleNonActiveCount(target.idxOwnSide)>0)
|
|
if move.statusMove?
|
|
score /= 1.5
|
|
elsif target.hp<=target.totalhp/2
|
|
score *= 1.5
|
|
end
|
|
end
|
|
end
|
|
# Don't prefer attacking the target if they'd be semi-invulnerable
|
|
if skill>=PBTrainerAI.highSkill && move.accuracy>0 &&
|
|
(target.semiInvulnerable? || target.effects[PBEffects::SkyDrop]>=0)
|
|
miss = true
|
|
miss = false if user.hasActiveAbility?(:NOGUARD) || target.hasActiveAbility?(:NOGUARD)
|
|
if miss && pbRoughStat(user,:SPEED,skill)>pbRoughStat(target,:SPEED,skill)
|
|
# Knows what can get past semi-invulnerability
|
|
if target.effects[PBEffects::SkyDrop]>=0
|
|
miss = false if move.hitsFlyingTargets?
|
|
else
|
|
if target.inTwoTurnAttack?("0C9","0CC","0CE") # Fly, Bounce, Sky Drop
|
|
miss = false if move.hitsFlyingTargets?
|
|
elsif target.inTwoTurnAttack?("0CA") # Dig
|
|
miss = false if move.hitsDiggingTargets?
|
|
elsif target.inTwoTurnAttack?("0CB") # Dive
|
|
miss = false if move.hitsDivingTargets?
|
|
end
|
|
end
|
|
end
|
|
score -= 80 if miss
|
|
end
|
|
# Pick a good move for the Choice items
|
|
if user.hasActiveItem?([:CHOICEBAND,:CHOICESPECS,:CHOICESCARF])
|
|
if move.baseDamage>=60; score += 60
|
|
elsif move.damagingMove?; score += 30
|
|
elsif move.function=="0F2"; score += 70 # Trick
|
|
else; score -= 60
|
|
end
|
|
end
|
|
# If user is asleep, prefer moves that are usable while asleep
|
|
if user.status == :SLEEP && !move.usableWhenAsleep?
|
|
user.eachMove do |m|
|
|
next unless m.usableWhenAsleep?
|
|
score -= 60
|
|
break
|
|
end
|
|
end
|
|
# If user is frozen, prefer a move that can thaw the user
|
|
if user.status == :FROZEN
|
|
if move.thawsUser?
|
|
score += 40
|
|
else
|
|
user.eachMove do |m|
|
|
next unless m.thawsUser?
|
|
score -= 60
|
|
break
|
|
end
|
|
end
|
|
end
|
|
# If target is frozen, don't prefer moves that could thaw them
|
|
if target.status == :FROZEN
|
|
user.eachMove do |m|
|
|
next if m.thawsUser?
|
|
score -= 60
|
|
break
|
|
end
|
|
end
|
|
end
|
|
# Adjust score based on how much damage it can deal
|
|
if move.damagingMove?
|
|
score = pbGetMoveScoreDamage(score,move,user,target,skill)
|
|
else # Status moves
|
|
# Don't prefer attacks which don't deal damage
|
|
score -= 10
|
|
# Account for accuracy of move
|
|
accuracy = pbRoughAccuracy(move,user,target,skill)
|
|
score *= accuracy/100.0
|
|
score = 0 if score<=10 && skill>=PBTrainerAI.highSkill
|
|
end
|
|
score = score.to_i
|
|
score = 0 if score<0
|
|
return score
|
|
end
|
|
|
|
#=============================================================================
|
|
# Add to a move's score based on how much damage it will deal (as a percentage
|
|
# of the target's current HP)
|
|
#=============================================================================
|
|
def pbGetMoveScoreDamage(score,move,user,target,skill)
|
|
# Don't prefer moves that are ineffective because of abilities or effects
|
|
return 0 if score<=0 || pbCheckMoveImmunity(score,move,user,target,skill)
|
|
# Calculate how much damage the move will do (roughly)
|
|
baseDmg = pbMoveBaseDamage(move,user,target,skill)
|
|
realDamage = pbRoughDamage(move,user,target,skill,baseDmg)
|
|
# Account for accuracy of move
|
|
accuracy = pbRoughAccuracy(move,user,target,skill)
|
|
realDamage *= accuracy/100.0
|
|
# Two-turn attacks waste 2 turns to deal one lot of damage
|
|
if move.chargingTurnMove? || move.function=="0C2" # Hyper Beam
|
|
realDamage *= 2/3 # Not halved because semi-invulnerable during use or hits first turn
|
|
end
|
|
# Prefer flinching external effects (note that move effects which cause
|
|
# flinching are dealt with in the function code part of score calculation)
|
|
if skill>=PBTrainerAI.mediumSkill
|
|
if !target.hasActiveAbility?(:INNERFOCUS) &&
|
|
!target.hasActiveAbility?(:SHIELDDUST) &&
|
|
target.effects[PBEffects::Substitute]==0
|
|
canFlinch = false
|
|
if move.canKingsRock? && user.hasActiveItem?([:KINGSROCK,:RAZORFANG])
|
|
canFlinch = true
|
|
end
|
|
if user.hasActiveAbility?(:STENCH) && !move.flinchingMove?
|
|
canFlinch = true
|
|
end
|
|
realDamage *= 1.3 if canFlinch
|
|
end
|
|
end
|
|
# Convert damage to percentage of target's remaining HP
|
|
damagePercentage = realDamage*100.0/target.hp
|
|
# Don't prefer weak attacks
|
|
# damagePercentage /= 2 if damagePercentage<20
|
|
# Prefer damaging attack if level difference is significantly high
|
|
damagePercentage *= 1.2 if user.level-10>target.level
|
|
# Adjust score
|
|
damagePercentage = 120 if damagePercentage>120 # Treat all lethal moves the same
|
|
damagePercentage += 40 if damagePercentage>100 # Prefer moves likely to be lethal
|
|
score += damagePercentage.to_i
|
|
return score
|
|
end
|
|
end
|