DocRock3r/infinitefusion-e18
1
0
Fork 0
mirror of https://github.com/infinitefusion/infinitefusion-e18.git synced 2025-12-10 22:54:59 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
a4d74a9663497d85c97d6719e9dc81fa5326a0f3
infinitefusion-e18/AI references/Old AI rewrite attempt/111_Reborn utilities.rb

1320 lines
51 KiB
Ruby
Raw Blame History

class PokeBattle_Battle
=begin
# Updated in Essentials
def pbRoughStat(battler,stat,skill)
if skill>=PBTrainerAI.highSkill && stat==PBStats::SPEED
return battler.pbSpeed
end
stagemul=[2,2,2,2,2,2,2,3,4,5,6,7,8]
stagediv=[8,7,6,5,4,3,2,2,2,2,2,2,2]
stage=battler.stages[stat]+6
value=0
value=battler.attack if stat==PBStats::ATTACK
value=battler.defense if stat==PBStats::DEFENSE
value=battler.speed if stat==PBStats::SPEED
value=battler.spatk if stat==PBStats::SPATK
value=battler.spdef if stat==PBStats::SPDEF
return (value*1.0*stagemul[stage]/stagediv[stage]).floor
end
=end
def pbBetterBaseDamage(move,attacker,opponent,skill,basedamage)
# Covers all function codes which have their own def pbBaseDamage
aimem = getAIMemory(skill,opponent.pokemonIndex)
case move.function
#---------------------------------------------------------------------------
when 0x71 # Counter
maxdam=60
if aimem.length > 0
for j in aimem
next if j.pbIsSpecial?(j.type)
next if j.basedamage<=1
tempdam = pbRoughDamage(j,opponent,attacker,skill,j.basedamage)*2
if tempdam>maxdam
maxdam=tempdam
end
end
end
basedamage = maxdam
when 0x72 # Mirror Coat
maxdam=60
if aimem.length > 0
for j in aimem
next if j.pbIsPhysical?(j.type)
next if j.basedamage<=1
tempdam = pbRoughDamage(j,opponent,attacker,skill,j.basedamage)*2
if tempdam>maxdam
maxdam=tempdam
end
end
end
basedamage = maxdam
when 0x73 # Metal Burst
maxdam=45
if aimem.length > 0
maxdam = checkAIdamage(aimem,attacker,opponent,skill)
end
basedamage = maxdam
#---------------------------------------------------------------------------
when 0xD4 # Bide
maxdam=30
if skill>=PBTrainerAI.bestSkill
if aimem.length > 0
maxdam = checkAIdamage(aimem,attacker,opponent,skill)
end
end
basedamage = maxdam
=begin
#---------------------------------------------------------------------------
# Missing: 010 - Stomp
#---------------------------------------------------------------------------
when 0x6A # SonicBoom
basedamage=20
when 0x6B # Dragon Rage
basedamage=40
when 0x6C # Super Fang
basedamage=(opponent.hp/2.0).floor
when 0x6D # Night Shade
basedamage=attacker.level
when 0x6E # Endeavor
basedamage=opponent.hp-attacker.hp
#---------------------------------------------------------------------------
when 0x6F # Psywave
basedamage=attacker.level
#---------------------------------------------------------------------------
when 0x70 # OHKO
basedamage=opponent.totalhp
#---------------------------------------------------------------------------
when 0x75, 0x12D # Surf, Shadow Storm
basedamage*=2 if $pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCB # Dive
when 0x76 # Earthquake
basedamage*=2 if $pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCA # Dig
when 0xD0 # Whirlpool
if skill>=PBTrainerAI.mediumSkill
basedamage*=2 if $pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCB # Dive
end
#---------------------------------------------------------------------------
when 0x77, 0x78 # Gust, Twister
basedamage*=2 if $pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xC9 || # Fly
$pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCC || # Bounce
$pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCE # Sky Drop
when 0x7B # Venoshock
if opponent.status==PBStatuses::POISON
basedamage*=2
end
when 0x7C # SmellingSalt
basedamage*=2 if opponent.status==PBStatuses::PARALYSIS && opponent.effects[PBEffects::Substitute]<=0
when 0x7D # Wake-Up Slap
basedamage*=2 if opponent.status==PBStatuses::SLEEP && opponent.effects[PBEffects::Substitute]<=0
when 0x7E # Facade
basedamage*=2 if attacker.status==PBStatuses::POISON ||
attacker.status==PBStatuses::BURN ||
attacker.status==PBStatuses::PARALYSIS
when 0x7F # Hex
basedamage*=2 if opponent.status!=0
when 0x80 # Brine
basedamage*=2 if opponent.hp<=(opponent.totalhp/2.0).floor
when 0x85 # Retaliate
basedamage*=2 if attacker.pbOwnSide.effects[PBEffects::Retaliate]
when 0x87 # Weather Ball
basedamage*=2 if pbWeather!=0
when 0x89 # Return
basedamage=[(attacker.happiness*2/5).floor,1].max
when 0x8A # Frustration
basedamage=[((255-attacker.happiness)*2/5).floor,1].max
when 0x8B # Eruption
basedamage=[(150*(attacker.hp.to_f)/attacker.totalhp).floor,1].max
when 0x8C # Crush Grip
basedamage=[(120*(opponent.hp.to_f)/opponent.totalhp).floor,1].max
when 0x8E # Stored Power
mult=0
for i in [PBStats::ATTACK,PBStats::DEFENSE,PBStats::SPEED,
PBStats::SPATK,PBStats::SPDEF,PBStats::ACCURACY,PBStats::EVASION]
mult+=attacker.stages[i] if attacker.stages[i]>0
end
basedamage=20*(mult+1)
when 0x8F # Punishment
mult=0
for i in [PBStats::ATTACK,PBStats::DEFENSE,PBStats::SPEED,
PBStats::SPATK,PBStats::SPDEF,PBStats::ACCURACY,PBStats::EVASION]
mult+=opponent.stages[i] if opponent.stages[i]>0
end
basedamage=[20*(mult+3),200].min
# when 0x90 # Hidden Power
# hp=pbHiddenPower(attacker.iv)
when 0x91 # Fury Cutter
basedamage=basedamage<<(attacker.effects[PBEffects::FuryCutter]-1)
when 0x92 # Echoed Voice
basedamage*=attacker.effects[PBEffects::EchoedVoice]
when 0x97 # Trump Card
dmgs=[200,80,60,50,40]
ppleft=[move.pp-1,4].min # PP is reduced before the move is used
basedamage=dmgs[ppleft]
when 0x98 # Flail
n=(48*(attacker.hp.to_f)/attacker.totalhp).floor
basedamage=20
basedamage=40 if n<33
basedamage=80 if n<17
basedamage=100 if n<10
basedamage=150 if n<5
basedamage=200 if n<2
when 0x99 # Electro Ball
n=(attacker.pbSpeed/opponent.pbSpeed).floor
basedamage=40
basedamage=60 if n>=1
basedamage=80 if n>=2
basedamage=120 if n>=3
basedamage=150 if n>=4
when 0x9A # Low Kick
weight=opponent.weight
basedamage=20
basedamage=40 if weight>100
basedamage=60 if weight>250
basedamage=80 if weight>500
basedamage=100 if weight>1000
basedamage=120 if weight>2000
when 0xF7 # Fling
if attacker.item ==0
basedamage=0
else
basedamage=10 if pbIsBerry?(attacker.item)
flingarray = PBStuff::FLINGDAMAGE
for i in flingarray.keys
data=flingarray[i]
if data
for j in data
basedamage = i if isConst?(attacker.item,PBItems,j)
end
end
end
end
when 0x113 # Spit Up
basedamage = 100*attacker.effects[PBEffects::Stockpile]
#---------------------------------------------------------------------------
when 0x86 # Acrobatics
basedamage*=2 if attacker.item ==0 || attacker.hasWorkingItem(:FLYINGGEM)
#---------------------------------------------------------------------------
when 0x8D # Gyro Ball
ospeed=pbRoughStat(opponent,PBStats::SPEED,skill)
aspeed=pbRoughStat(attacker,PBStats::SPEED,skill)
basedamage=[[(25*ospeed/aspeed).floor,150].min,1].max
#---------------------------------------------------------------------------
when 0x94 # Present
basedamage=50
#---------------------------------------------------------------------------
when 0x95 # Magnitude
basedamage=71
basedamage*=2 if $pkmn_move[opponent.effects[PBEffects::TwoTurnAttack]][0] #the function code of the current move==0xCA # Dig
#---------------------------------------------------------------------------
when 0x96 # Natural Gift
damagearray = PBStuff::NATURALGIFTDAMAGE
haveanswer=false
for i in damagearray.keys
data=damagearray[i]
if data
for j in data
if isConst?(attacker.item,PBItems,j)
basedamage=i; haveanswer=true; break
end
end
end
break if haveanswer
end
#---------------------------------------------------------------------------
when 0x9B # Heavy Slam
n=(attacker.weight/opponent.weight).floor
basedamage=40
basedamage=60 if n>=2
basedamage=80 if n>=3
basedamage=100 if n>=4
basedamage=120 if n>=5
#---------------------------------------------------------------------------
when 0xA0 # Frost Breath
basedamage*=1.5
#---------------------------------------------------------------------------
when 0xBD, 0xBE # Double Kick, Twineedle
basedamage*=2
#---------------------------------------------------------------------------
when 0xBF # Triple Kick
basedamage*=6
#---------------------------------------------------------------------------
when 0xC0 # Fury Attack
if (!attacker.abilitynulled && attacker.ability == PBAbilities::SKILLLINK)
basedamage*=5
else
basedamage=(basedamage*19/6).floor
end
#---------------------------------------------------------------------------
when 0xC1 # Beat Up
party=pbParty(attacker.index)
mult=0
for i in 0...party.length
mult+=1 if party[i] && !party[i].isEgg? &&
party[i].hp>0 && party[i].status==0
end
basedamage*=mult
#---------------------------------------------------------------------------
when 0xC4 # SolarBeam
if pbWeather!=0 && pbWeather!=PBWeather::SUNNYDAY
basedamage=(basedamage*0.5).floor
end
#---------------------------------------------------------------------------
when 0xD3 # Rollout
if skill>=PBTrainerAI.mediumSkill
basedamage*=2 if attacker.effects[PBEffects::DefenseCurl]
end
#---------------------------------------------------------------------------
when 0xE1 # Final Gambit
basedamage=attacker.hp
#---------------------------------------------------------------------------
# Missing: 144 - Flying Press
#---------------------------------------------------------------------------
when 0x166 # Stomping Tantrum
if attacker.effects[PBEffects::Tantrum]
basedamage*=2
end
#---------------------------------------------------------------------------
# Missing: 175 - Double Iron Bash
#---------------------------------------------------------------------------
# Added in Reborn
when 0xF0 # Knock Off
if opponent.item!=0 && !pbIsUnlosableItem(opponent,opponent.item)
basedamage*=1.5
end
#---------------------------------------------------------------------------
# Added in Reborn - n/a
when 0x79 # Fusion Bolt
basedamage*=2 if previousMove == 127 || previousMove == 131
#---------------------------------------------------------------------------
# Added in Reborn - n/a
when 0x7A # Fusion Flare
basedamage*=2 if previousMove == 64 || previousMove == 68
#---------------------------------------------------------------------------
=end
end
return basedamage
end
def pbRoughDamage(move,attacker,opponent,skill,basedamage)
if opponent.species==0 || attacker.species==0
return 0
end
move = pbChangeMove(move,attacker)
basedamage = move.basedamage
if move.basedamage==0
return 0
end
#Temporarly mega-ing pokemon if it can #perry
if pbCanMegaEvolve?(attacker.index)
attacker.pokemon.makeMega
attacker.pbUpdate(true)
attacker.form=attacker.startform
megaEvolved=true
end
if skill>=PBTrainerAI.highSkill
basedamage = pbBetterBaseDamage(move,attacker,opponent,skill,basedamage)
end
if move.function==0x6A || # SonicBoom
move.function==0x6B || # Dragon Rage
move.function==0x6C || # Super Fang
move.function==0x6D || # Night Shade
move.function==0x6E || # Endeavor
move.function==0x6F || # Psywave
move.function==0x70 || # OHKO
move.function==0x71 || # Counter
move.function==0x72 || # Mirror Coat
move.function==0x73 || # Metal Burst
move.function==0xD4 || # Bide
move.function==0xE1 # Final Gambit
attacker.pbUpdate(true) if defined?(megaEvolved) && megaEvolved==true #un-mega pokemon #perry
return basedamage
end
type=move.type
# More accurate move type (includes Normalize, most type-changing moves, etc.)
if skill>=PBTrainerAI.minimumSkill
type=move.pbType(type,attacker,opponent)
end
oppitemworks = opponent.itemWorks?
attitemworks = attacker.itemWorks?
# ATTACKING/BASE DAMAGE SECTION
atk=pbRoughStat(attacker,PBStats::ATTACK,skill)
if attacker.species==681
originalform = attacker.form
dummymon = pbAegislashStats(attacker)
dummymon.pbUpdate
atk=pbRoughStat(dummymon,PBStats::ATTACK,skill)
dummymon.form = originalform
dummymon.pbUpdate
end
if move.function==0x121 # Foul Play
atk=pbRoughStat(opponent,PBStats::ATTACK,skill)
end
if type>=0 && move.pbIsSpecial?(type)
atk=pbRoughStat(attacker,PBStats::SPATK,skill)
if attacker.species==681
originalform = attacker.form
dummymon = pbAegislashStats(attacker)
dummymon.pbUpdate
atk=pbRoughStat(dummymon,PBStats::SPATK,skill)
dummymon.form = originalform
dummymon.pbUpdate
end
if move.function==0x121 # Foul Play
atk=pbRoughStat(opponent,PBStats::SPATK,skill)
end
end
if skill>=PBTrainerAI.mediumSkill
############ ATTACKER ABILITY CHECKS ############
if !attacker.abilitynulled
#Technician
if attacker.ability == PBAbilities::TECHNICIAN
if (basedamage<=60)
basedamage=(basedamage*1.5).round
end
# Iron Fist
elsif attacker.ability == PBAbilities::IRONFIST
if move.isPunchingMove?
basedamage=(basedamage*1.2).round
end
# Strong Jaw
elsif attacker.ability == PBAbilities::STRONGJAW
if (move.id == PBMoves::BITE || move.id == PBMoves::CRUNCH ||
move.id == PBMoves::THUNDERFANG || move.id == PBMoves::FIREFANG ||
move.id == PBMoves::ICEFANG || move.id == PBMoves::POISONFANG ||
move.id == PBMoves::HYPERFANG || move.id == PBMoves::PSYCHICFANGS)
basedamage=(basedamage*1.5).round
end
#Tough Claws
elsif attacker.ability == PBAbilities::TOUGHCLAWS
if move.isContactMove?
basedamage=(basedamage*1.3).round
end
# Reckless
elsif attacker.ability == PBAbilities::RECKLESS
if @function==0xFA || # Take Down, etc.
@function==0xFB || # Double-Edge, etc.
@function==0xFC || # Head Smash
@function==0xFD || # Volt Tackle
@function==0xFE || # Flare Blitz
@function==0x10B || # Jump Kick, Hi Jump Kick
@function==0x130 # Shadow End
basedamage=(basedamage*1.2).round
end
# Flare Boost
elsif attacker.ability == PBAbilities::FLAREBOOST
if attacker.status==PBStatuses::BURN && move.pbIsSpecial?(type)
basedamage=(basedamage*1.5).round
end
# Toxic Boost
elsif attacker.ability == PBAbilities::TOXICBOOST
if attacker.status==PBStatuses::POISON && move.pbIsPhysical?(type)
basedamage=(basedamage*1.5).round
end
# Rivalry
elsif attacker.ability == PBAbilities::RIVALRY
if attacker.gender!=2 && opponent.gender!=2
if attacker.gender==opponent.gender
basedamage=(basedamage*1.25).round
else
basedamage=(basedamage*0.75).round
end
end
# Sand Force
elsif attacker.ability == PBAbilities::SANDFORCE
if pbWeather==PBWeather::SANDSTORM && (type == PBTypes::ROCK ||
(type == PBTypes::GROUND) || type == PBTypes::STEEL)
basedamage=(basedamage*1.3).round
end
# Analytic
elsif attacker.ability == PBAbilities::ANALYTIC
if opponent.hasMovedThisRound?
basedamage = (basedamage*1.3).round
end
# Sheer Force
elsif attacker.ability == PBAbilities::SHEERFORCE
if move.addlEffect>0
basedamage=(basedamage*1.3).round
end
# Normalize
elsif attacker.ability == PBAbilities::NORMALIZE
type=PBTypes::NORMAL
basedamage=(basedamage*1.2).round
# Hustle
elsif attacker.ability == PBAbilities::HUSTLE
if move.pbIsPhysical?(type)
atk=(atk*1.5).round
end
# Guts
elsif attacker.ability == PBAbilities::GUTS
if attacker.status!=0 && move.pbIsPhysical?(type)
atk=(atk*1.5).round
end
#Plus/Minus
elsif attacker.ability == PBAbilities::PLUS || attacker.ability == PBAbilities::MINUS
if move.pbIsSpecial?(type)
partner=attacker.pbPartner
if (!partner.abilitynulled && partner.ability == PBAbilities::PLUS) || (!partner.abilitynulled && partner.ability == PBAbilities::MINUS)
atk=(atk*1.5).round
end
end
#Defeatist
elsif attacker.ability == PBAbilities::DEFEATIST
if attacker.hp<=(attacker.totalhp/2.0).floor
atk=(atk*0.5).round
end
#Pure/Huge Power
elsif attacker.ability == PBAbilities::PUREPOWER || attacker.ability == PBAbilities::HUGEPOWER
if move.pbIsPhysical?(type)
atk=(atk*2.0).round
end
#Solar Power
elsif attacker.ability == PBAbilities::SOLARPOWER
if pbWeather==PBWeather::SUNNYDAY && move.pbIsSpecial?(type)
atk=(atk*1.5).round
end
#Flash Fire
elsif attacker.ability == PBAbilities::FLASHFIRE
if attacker.effects[PBEffects::FlashFire] && type == PBTypes::FIRE
atk=(atk*1.5).round
end
#Slow Start
elsif attacker.ability == PBAbilities::SLOWSTART
if attacker.turncount<5 && move.pbIsPhysical?(type)
atk=(atk*0.5).round
end
# Type Changing Abilities
elsif type == PBTypes::NORMAL && attacker.ability != PBAbilities::NORMALIZE
# Aerilate
if attacker.ability == PBAbilities::AERILATE
type=PBTypes::FLYING
basedamage=(basedamage*1.2).round
# Galvanize
elsif attacker.ability == PBAbilities::GALVANIZE
type=PBTypes::ELECTRIC
basedamage=(basedamage*1.2).round
# Pixilate
elsif attacker.ability == PBAbilities::PIXILATE
type=PBTypes::FAIRY
basedamage=(basedamage*1.2).round
# Refrigerate
elsif attacker.ability == PBAbilities::REFRIGERATE
type=PBTypes::ICE
basedamage=(basedamage*1.2).round
end
end
end
############ OPPONENT ABILITY CHECKS ############
if !opponent.abilitynulled && !(opponent.moldbroken)
# Heatproof
if opponent.ability == PBAbilities::HEATPROOF
if type == PBTypes::FIRE
basedamage=(basedamage*0.5).round
end
# Dry Skin
elsif opponent.ability == PBAbilities::DRYSKIN
if type == PBTypes::FIRE
basedamage=(basedamage*1.25).round
end
elsif opponent.ability == PBAbilities::THICKFAT
if type == PBTypes::ICE || type == PBTypes::FIRE
atk=(atk*0.5).round
end
end
end
############ ATTACKER ITEM CHECKS ############
if attitemworks #don't bother with this if it doesn't work
#Type-boosting items
case type
when 0
if attacker.item == PBItems::SILKSCARF
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::NORMALGEM
basedamage=(basedamage*1.3).round
end
when 1
if (attacker.item == PBItems::BLACKBELT || attacker.item == PBItems::FISTPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::FIGHTINGGEM
basedamage=(basedamage*1.3).round
end
when 2
if (attacker.item == PBItems::SHARPBEAK || attacker.item == PBItems::SKYPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::FLYINGGEM
basedamage=(basedamage*1.3).round
end
when 3
if (attacker.item == PBItems::POISONBARB || attacker.item == PBItems::TOXICPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::POISONGEM
basedamage=(basedamage*1.3).round
end
when 4
if (attacker.item == PBItems::SOFTSAND || attacker.item == PBItems::EARTHPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::GROUNDGEM
basedamage=(basedamage*1.3).round
end
when 5
if (attacker.item == PBItems::HARDSTONE || attacker.item == PBItems::STONEPLATE || attacker.item == PBItems::ROCKINCENSE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::ROCKGEM
basedamage=(basedamage*1.3).round
end
when 6
if (attacker.item == PBItems::SILVERPOWDER || attacker.item == PBItems::INSECTPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::BUGGEM
basedamage=(basedamage*1.3).round
end
when 7
if (attacker.item == PBItems::SPELLTAG || attacker.item == PBItems::SPOOKYPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::GHOSTGEM
basedamage=(basedamage*1.3).round
end
when 8
if (attacker.item == PBItems::METALCOAT || attacker.item == PBItems::IRONPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::STEELGEM
basedamage=(basedamage*1.3).round
end
when 9 #?????
when 10
if (attacker.item == PBItems::CHARCOAL || attacker.item == PBItems::FLAMEPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::FIREGEM
basedamage=(basedamage*1.3).round
end
when 11
if (attacker.item == PBItems::MYSTICWATER || attacker.item == PBItems::SPLASHPLATE ||
attacker.item == PBItems::SEAINCENSE || attacker.item == PBItems::WAVEINCENSE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::WATERGEM
basedamage=(basedamage*1.3).round
end
when 12
if (attacker.item == PBItems::MIRACLESEED || attacker.item == PBItems::MEADOWPLATE || attacker.item == PBItems::ROSEINCENSE) #it me
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::GRASSGEM
basedamage=(basedamage*1.3).round
end
when 13
if (attacker.item == PBItems::MAGNET || attacker.item == PBItems::ZAPPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::ELECTRICGEM
basedamage=(basedamage*1.3).round
end
when 14
if (attacker.item == PBItems::TWISTEDSPOON || attacker.item == PBItems::MINDPLATE || attacker.item == PBItems::ODDINCENSE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::PSYCHICGEM
basedamage=(basedamage*1.3).round
end
when 15
if (attacker.item == PBItems::NEVERMELTICE || attacker.item == PBItems::ICICLEPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::ICEGEM
basedamage=(basedamage*1.3).round
end
when 16
if (attacker.item == PBItems::DRAGONFANG || attacker.item == PBItems::DRACOPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::DRAGONGEM
basedamage=(basedamage*1.3).round
end
when 17
if (attacker.item == PBItems::BLACKGLASSES || attacker.item == PBItems::DREADPLATE)
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::DARKGEM
basedamage=(basedamage*1.3).round
end
when 18
if attacker.item == PBItems::PIXIEPLATE
basedamage=(basedamage*1.2).round
elsif attacker.item == PBItems::FAIRYGEM
basedamage=(basedamage*1.3).round
end
end
# Muscle Band
if attacker.item == PBItems::MUSCLEBAND && move.pbIsPhysical?(type)
basedamage=(basedamage*1.1).round
# Wise Glasses
elsif attacker.item == PBItems::WISEGLASSES && move.pbIsSpecial?(type)
basedamage=(basedamage*1.1).round
# Legendary Orbs
elsif attacker.item == PBItems::LUSTROUSORB
if (attacker.species == PBSpecies::PALKIA) && (type == PBTypes::DRAGON || type == PBTypes::WATER)
basedamage=(basedamage*1.2).round
end
elsif attacker.item == PBItems::ADAMANTORB
if (attacker.species == PBSpecies::DIALGA) && (type == PBTypes::DRAGON || type == PBTypes::STEEL)
basedamage=(basedamage*1.2).round
end
elsif attacker.item == PBItems::GRISEOUSORB
if (attacker.species == PBSpecies::GIRATINA) && (type == PBTypes::DRAGON || type == PBTypes::GHOST)
basedamage=(basedamage*1.2).round
end
elsif attacker.item == PBItems::SOULDEW
if (attacker.species == PBSpecies::LATIAS) || (attacker.species == PBSpecies::LATIOS) &&
(type == PBTypes::DRAGON || type == PBTypes::PSYCHIC)
basedamage=(basedamage*1.2).round
end
end
end
############ MISC CHECKS ############
# Charge
if attacker.effects[PBEffects::Charge]>0 && type == PBTypes::ELECTRIC
basedamage=(basedamage*2.0).round
end
# Helping Hand
if attacker.effects[PBEffects::HelpingHand]
basedamage=(basedamage*1.5).round
end
# Water/Mud Sport
if type == PBTypes::FIRE
if @field.effects[PBEffects::WaterSport]>0
basedamage=(basedamage*0.33).round
end
elsif type == PBTypes::ELECTRIC
if @field.effects[PBEffects::MudSport]>0
basedamage=(basedamage*0.33).round
end
# Dark Aura/Aurabreak
elsif type == PBTypes::DARK
for i in @battlers
if i.ability == PBAbilities::DARKAURA
breakaura=0
for j in @battlers
if j.ability == PBAbilities::AURABREAK
breakaura+=1
end
end
if breakaura!=0
basedamage=(basedamage*2/3).round
else
basedamage=(basedamage*1.33).round
end
end
end
# Fairy Aura/Aurabreak
elsif type == PBTypes::FAIRY
for i in @battlers
if i.ability == PBAbilities::FAIRYAURA
breakaura=0
for j in @battlers
if j.ability == PBAbilities::AURABREAK
breakaura+=1
end
end
if breakaura!=0
basedamage=(basedamage*2/3).round
else
basedamage=(basedamage*1.3).round
end
end
end
end
#Battery
if (!attacker.pbPartner.abilitynulled && attacker.pbPartner.ability == PBAbilities::BATTERY) && move.pbIsSpecial?(type)
atk=(atk*1.3).round
end
#Flower Gift
if pbWeather==PBWeather::SUNNYDAY && move.pbIsPhysical?(type)
if (!attacker.abilitynulled && attacker.ability == PBAbilities::FLOWERGIFT) &&
(attacker.species == PBSpecies::CHERRIM)
atk=(atk*1.5).round
end
if (!attacker.pbPartner.abilitynulled && attacker.pbPartner.ability == PBAbilities::FLOWERGIFT) &&
attacker.pbPartner.species == PBSpecies::CHERRIM
atk=(atk*1.5).round
end
end
end
# Pinch Abilities
if !attacker.abilitynulled
if skill>=PBTrainerAI.mediumSkill
if attacker.ability == PBAbilities::OVERGROW
if attacker.hp<=(attacker.totalhp/3.0).floor || type == PBTypes::GRASS
atk=(atk*1.5).round
end
elsif attacker.ability == PBAbilities::BLAZE
if attacker.hp<=(attacker.totalhp/3.0).floor || type == PBTypes::FIRE
atk=(atk*1.5).round
end
elsif attacker.ability == PBAbilities::TORRENT
if attacker.hp<=(attacker.totalhp/3.0).floor || type == PBTypes::WATER
atk=(atk*1.5).round
end
elsif attacker.ability == PBAbilities::SWARM
if attacker.hp<=(attacker.totalhp/3.0).floor || type == PBTypes::BUG
atk=(atk*1.5).round
end
end
end
end
# Attack-boosting items
if skill>=PBTrainerAI.highSkill
if (attitemworks && attacker.item == PBItems::THICKCLUB)
if ((attacker.species == PBSpecies::CUBONE) || (attacker.species == PBSpecies::MAROWAK)) && move.pbIsPhysical?(type)
atk=(atk*2.0).round
end
elsif (attitemworks && attacker.item == PBItems::DEEPSEATOOTH)
if (attacker.species == PBSpecies::CLAMPERL) && move.pbIsSpecial?(type)
atk=(atk*2.0).round
end
elsif (attitemworks && attacker.item == PBItems::LIGHTBALL)
if (attacker.species == PBSpecies::PIKACHU)
atk=(atk*2.0).round
end
elsif (attitemworks && attacker.item == PBItems::CHOICEBAND) && move.pbIsPhysical?(type)
atk=(atk*1.5).round
elsif (attitemworks && attacker.item == PBItems::CHOICESPECS) && move.pbIsSpecial?(type)
atk=(atk*1.5).round
end
end
# Get base defense stat
defense=pbRoughStat(opponent,PBStats::DEFENSE,skill)
applysandstorm=false
if type>=0 && move.pbIsSpecial?(type)
if move.function!=0x122 # Psyshock
defense=pbRoughStat(opponent,PBStats::SPDEF,skill)
applysandstorm=true
end
end
if opponent.effects[PBEffects::PowerTrick]
defense=pbRoughStat(opponent,PBStats::ATTACK,skill)
end
defense = 1 if (defense == 0 || !defense)
if skill>=PBTrainerAI.mediumSkill
# Sandstorm weather
if pbWeather==PBWeather::SANDSTORM
if opponent.pbHasType?(:ROCK) && applysandstorm
defense=(defense*1.5).round
end
end
# Defensive Abilities
if !opponent.abilitynulled
if opponent.ability == PBAbilities::MARVELSCALE
if move.pbIsPhysical?(type)
if opponent.status>0
defense=(defense*1.5).round
end
end
elsif opponent.ability == PBAbilities::GRASSPELT
if move.pbIsPhysical?(type) && $fefieldeffect == 2 # Grassy Terrain
defense=(defense*1.5).round
end
elsif opponent.ability == PBAbilities::FLUFFY && !(opponent.moldbroken)
if move.isContactMove? && !(!attacker.abilitynulled && attacker.ability == PBAbilities::LONGREACH)
defense=(defense*2).round
end
if type == PBTypes::FIRE
defense=(defense*0.5).round
end
elsif opponent.ability == PBAbilities::FURCOAT
if move.pbIsPhysical?(type) && !(opponent.moldbroken)
defense=(defense*2).round
end
end
end
if pbWeather==PBWeather::SUNNYDAY && move.pbIsSpecial?(type)
if (!opponent.abilitynulled && opponent.ability == PBAbilities::FLOWERGIFT) &&
(opponent.species == PBSpecies::CHERRIM)
defense=(defense*1.5).round
end
if (!opponent.pbPartner.abilitynulled && opponent.pbPartner.ability == PBAbilities::FLOWERGIFT) && opponent.pbPartner.species == PBSpecies::CHERRIM
defense=(defense*1.5).round
end
end
end
# Various field boosts
if skill>=PBTrainerAI.bestSkill
if $fefieldeffect == 3 && move.pbIsSpecial?(type) && opponent.pbHasType?(:FAIRY) # Misty Terrain
defense=(defense*1.5).round
end
end
# Defense-boosting items
if skill>=PBTrainerAI.highSkill
if (oppitemworks && opponent.item == PBItems::EVIOLITE)
evos=pbGetEvolvedFormData(opponent.species)
if evos && evos.length>0
defense=(defense*1.5).round
end
elsif (oppitemworks && opponent.item == PBItems::ASSAULTVEST)
if move.pbIsSpecial?(type)
defense=(defense*1.5).round
end
elsif (oppitemworks && opponent.item == PBItems::DEEPSEASCALE)
if (opponent.species == PBSpecies::CLAMPERL) && move.pbIsSpecial?(type)
defense=(defense*2.0).round
end
elsif (oppitemworks && opponent.item == PBItems::METALPOWDER)
if (opponent.species == PBSpecies::DITTO) && !opponent.effects[PBEffects::Transform] && move.pbIsPhysical?(type)
defense=(defense*2.0).round
end
end
end
# Prism Armor & Shadow Shield
if skill>=PBTrainerAI.bestSkill
if (!attacker.abilitynulled && attacker.ability == PBAbilities::PRISMARMOR) ||
(!attacker.abilitynulled && attacker.ability == PBAbilities::SHADOWSHIELD)
defense=(defense*1.5).round
end
end
# Main damage calculation
damage=(((2.0*attacker.level/5+2).floor*basedamage*atk/defense).floor/50).floor+2 if basedamage >= 0
# Multi-targeting attacks
if skill>=PBTrainerAI.mediumSkill
if move.pbTargetsAll?(attacker)
damage=(damage*0.75).round
end
end
#determining if pokemon is grounded
isgrounded=move.pbTypeModifier(PBTypes::GROUND,opponent,attacker)
isgrounded = 4 if (isgrounded==0 && attacker.effects[PBEffects::Roost])
isgrounded = 0 if attacker.effects[PBEffects::MagnetRise]>0
isgrounded = 0 if attacker.ability == (PBAbilities::LEVITATE)
isgrounded = 0 if (attitemworks && attacker.item == PBItems::AIRBALLOON)
# Field Boosts
if skill>=PBTrainerAI.bestSkill
case $fefieldeffect
when 1 # Electric Terrain
if type == PBTypes::ELECTRIC
if isgrounded != 0
damage=(damage*1.5).floor
end
end
when 2 # Grassy Terrain
if type == PBTypes::GRASS
if isgrounded != 0
damage=(damage*1.5).floor
end
end
when 3 # Misty Terrain
if type == PBTypes::DRAGON
damage=(damage*0.5).floor
end
when 37 # Psychic Terrain
if type == PBTypes::PSYCHIC
if isgrounded != 0
damage=(damage*1.5).floor
end
end
end
end
# Weather
if skill>=PBTrainerAI.mediumSkill
case pbWeather
when PBWeather::SUNNYDAY
if field.effects[PBEffects::HarshSunlight] &&
type == PBTypes::WATER
damage=0
end
if type == PBTypes::FIRE
damage=(damage*1.5).round
elsif type == PBTypes::WATER
damage=(damage*0.5).round
end
when PBWeather::RAINDANCE
if field.effects[PBEffects::HeavyRain] &&
type == PBTypes::FIRE
damage=0
end
if type == PBTypes::FIRE
damage=(damage*0.5).round
elsif type == PBTypes::WATER
damage=(damage*1.5).round
end
end
end
outgoingdamage = false
if attacker.index == 2 && pbOwnedByPlayer?(attacker.index) == false
if opponent.index==1 || opponent.index==3
outgoingdamage = true
end
else
if opponent.index==0 || opponent.index==2
outgoingdamage = true
end
end
if outgoingdamage == true
random=85
damage=(damage*random/100.0).floor
end
# Water Bubble
if skill>=PBTrainerAI.mediumSkill
if (!attacker.abilitynulled && attacker.ability == PBAbilities::WATERBUBBLE) && type == PBTypes::WATER
damage=(damage*=2).round
end
# STAB
if (attacker.pbHasType?(type) || (!attacker.abilitynulled && attacker.ability == PBAbilities::PROTEAN))
if (!attacker.abilitynulled && attacker.ability == PBAbilities::ADAPTABILITY)
damage=(damage*2).round
else
damage=(damage*1.5).round
end
elsif ((!attacker.abilitynulled && attacker.ability == PBAbilities::STEELWORKER) && type == PBTypes::STEEL)
damage=(damage*1.5).round
end
end
# Type effectiveness
#typemod=pbTypeModifier(type,attacker,opponent)
typemod=pbTypeModNoMessages(type,attacker,opponent,move,skill)
if skill>=PBTrainerAI.minimumSkill
damage=(damage*typemod/4.0).round
end
# Water Bubble
if skill>=PBTrainerAI.mediumSkill
if (!opponent.abilitynulled && opponent.ability == PBAbilities::WATERBUBBLE) && type == PBTypes::FIRE
damage=(damage*=0.5).round
end
# Burn
if attacker.status==PBStatuses::BURN && move.pbIsPhysical?(type) &&
!(!attacker.abilitynulled && attacker.ability == PBAbilities::GUTS)
damage=(damage*0.5).round
end
end
# Make sure damage is at least 1
damage=1 if damage<1
# Screens
if skill>=PBTrainerAI.highSkill
if move.pbIsPhysical?(type)
if opponent.pbOwnSide.effects[PBEffects::Reflect]>0 || opponent.pbOwnSide.effects[PBEffects::AuroraVeil]>0
if !opponent.pbPartner.isFainted?
damage=(damage*0.66).round
else
damage=(damage*0.5).round
end
end
elsif move.pbIsSpecial?(type)
if opponent.pbOwnSide.effects[PBEffects::Reflect]>0 || opponent.pbOwnSide.effects[PBEffects::AuroraVeil]>0
if !opponent.pbPartner.isFainted?
damage=(damage*0.66).round
else
damage=(damage*0.5).round
end
end
end
end
# Multiscale
if skill>=PBTrainerAI.mediumSkill
if !opponent.abilitynulled
if opponent.ability == PBAbilities::MULTISCALE || opponent.ability == PBAbilities::SHADOWSHIELD
if opponent.hp==opponent.totalhp
damage=(damage*0.5).round
end
elsif opponent.ability == PBAbilities::SOLIDROCK || opponent.ability == PBAbilities::FILTER || opponent.ability == PBAbilities::PRISMARMOR
if typemod>4
damage=(damage*0.75).round
end
end
end
if (!opponent.pbPartner.abilitynulled && opponent.pbPartner.ability == PBAbilities::FRIENDGUARD)
damage=(damage*0.75).round
end
if (!attacker.abilitynulled && attacker.ability == PBAbilities::STAKEOUT) && switchedOut[opponent.index]
damage=(damage*2.0).round
end
end
# Tinted Lens
if skill>=PBTrainerAI.mediumSkill
if !attacker.abilitynulled && attacker.ability == PBAbilities::TINTEDLENS && typemod<4
damage=(damage*2.0).round
end
end
# Neuroforce
if skill>=PBTrainerAI.mediumSkill
if !attacker.abilitynulled && attacker.ability == PBAbilities::NEUROFORCE && typemod>4
damage=(damage*1.25).round
end
end
# Final damage-altering items
if skill>=PBTrainerAI.highSkill
if (attitemworks && attacker.item == PBItems::METRONOME)
if attacker.effects[PBEffects::Metronome]>4
damage=(damage*2.0).round
else
met=1.0+attacker.effects[PBEffects::Metronome]*0.2
damage=(damage*met).round
end
elsif (attitemworks && attacker.item == PBItems::EXPERTBELT) && typemod>4
damage=(damage*1.2).round
elsif (attitemworks && attacker.item == PBItems::LIFEORB)
damage=(damage*1.3).round
elsif typemod>4 && oppitemworks
#SE Damage reducing berries
if (opponent.item == (PBItems::CHOPLEBERRY) && type == PBTypes::FIGHTING) ||
(opponent.item == (PBItems::COBABERRY) && type == PBTypes::FLYING) ||
(opponent.item == (PBItems::KEBIABERRY) && type == PBTypes::POISON) ||
(opponent.item == (PBItems::SHUCABERRY) && (type == PBTypes::GROUND)) ||
(opponent.item == (PBItems::CHARTIBERRY) && type == PBTypes::ROCK) ||
(opponent.item == (PBItems::TANGABERRY) && type == PBTypes::BUG) ||
(opponent.item == (PBItems::KASIBBERRY) && type == PBTypes::GHOST) ||
(opponent.item == (PBItems::BABIRIBERRY) && type == PBTypes::STEEL) ||
(opponent.item == (PBItems::OCCABERRY) && type == PBTypes::FIRE) ||
(opponent.item == (PBItems::PASSHOBERRY) && type == PBTypes::WATER) ||
(opponent.item == (PBItems::RINDOBERRY) && type == PBTypes::GRASS) ||
(opponent.item == (PBItems::WACANBERRY) && type == PBTypes::ELECTRIC) ||
(opponent.item == (PBItems::PAYAPABERRY) && type == PBTypes::PSYCHIC) ||
(opponent.item == (PBItems::YACHEBERRY) && type == PBTypes::ICE) ||
(opponent.item == (PBItems::HABANBERRY) && type == PBTypes::DRAGON) ||
(opponent.item == (PBItems::COLBURBERRY) && type == PBTypes::DARK) ||
(opponent.item == (PBItems::ROSELIBERRY) && type == PBTypes::FAIRY)
if opponent.ability == (PBAbilities::RIPEN)
damage=(damage*0.25).round
else
damage=(damage*0.5).round
end
end
end
end
# pbModifyDamage - TODO
# "AI-specific calculations below"
# Increased critical hit rates
if skill>=PBTrainerAI.mediumSkill
critrate = pbAICritRate(attacker,opponent,move)
if critrate==2
damage=(damage*1.25).round
elsif critrate>2
damage=(damage*1.5).round
end
end
attacker.pbUpdate(true) if defined?(megaEvolved) && megaEvolved==true #un-mega pokemon #perry
return damage
end
def pbTypeModNoMessages(type,attacker,opponent,move,skill)
return 4 if type<0
id = move.id
if !attacker.abilitynulled
type=PBTypes::ELECTRIC if type == PBTypes::NORMAL && attacker.ability == PBAbilities::GALVANIZE
type=PBTypes::FLYING if type == PBTypes::NORMAL && attacker.ability == PBAbilities::AERILATE
type=PBTypes::FAIRY if type == PBTypes::NORMAL && attacker.ability == PBAbilities::PIXILATE
type=PBTypes::ICE if type == PBTypes::NORMAL && attacker.ability == PBAbilities::REFRIGERATE
type=PBTypes::NORMAL if attacker.ability == PBAbilities::NORMALIZE
end
if !opponent.abilitynulled && !(opponent.moldbroken)
if opponent.ability == PBAbilities::SAPSIPPER
return 0 if type == PBTypes::GRASS || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::GRASS
elsif opponent.ability == PBAbilities::LEVITATE
return 0 if type == PBTypes::GROUND || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::GROUND
elsif opponent.ability == PBAbilities::STORMDRAIN
return 0 if type == PBTypes::WATER || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::WATER
elsif opponent.ability == PBAbilities::LIGHTNINGROD
return 0 if type == PBTypes::ELECTRIC || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::ELECTRIC
elsif opponent.ability == PBAbilities::MOTORDRIVE
return 0 if type == PBTypes::ELECTRIC || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::ELECTRIC
elsif opponent.ability == PBAbilities::DRYSKIN
return 0 if type == PBTypes::WATER || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::WATER && opponent.effects[PBEffects::HealBlock]==0
elsif opponent.ability == PBAbilities::VOLTABSORB
return 0 if type == PBTypes::ELECTRIC || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::ELECTRIC && opponent.effects[PBEffects::HealBlock]==0
elsif opponent.ability == PBAbilities::WATERABSORB
return 0 if type == PBTypes::WATER || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::WATER && opponent.effects[PBEffects::HealBlock]==0
elsif opponent.ability == PBAbilities::BULLETPROOF
return 0 if (PBStuff::BULLETMOVE).include?(id)
elsif opponent.ability == PBAbilities::FLASHFIRE
return 0 if type == PBTypes::FIRE || move.FieldTypeChange(attacker,opponent,1,true)==PBTypes::FIRE
elsif move.basedamage>0 && opponent.ability == PBAbilities::TELEPATHY
partner=attacker.pbPartner
if opponent.index == partner.index
return 0
end
end
end
# UPDATE Implementing Flying Press + Freeze Dry
faintedcount=0
for i in pbParty(opponent.index)
next if i.nil?
faintedcount+=1 if (i.hp==0 && i.hp!=0)
end
if opponent.effects[PBEffects::Illusion]
if skill>=PBTrainerAI.bestSkill
if !(opponent.turncount>1 || faintedcount>2)
zorovar=true
else
zorovar=false
end
elsif skill>=PBTrainerAI.highSkill
if !(faintedcount>4)
zorovar=true
else
zorovar=false
end
else
zorovar = true
end
else
zorovar=false
end
typemod=move.pbTypeModifier(type,attacker,opponent,zorovar)
typemod2= nil
typemod3= nil
if id == PBMoves::FREEZEDRY && (opponent.pbHasType?(PBTypes::WATER))
typemod*= 4
end
if pbWeather==PBWeather::STRONGWINDS &&
((opponent.pbHasType?(PBTypes::FLYING)) &&
!opponent.effects[PBEffects::Roost]) &&
(type == PBTypes::ELECTRIC || type == PBTypes::ICE ||
type == PBTypes::ROCK)
typemod /= 2
end
if id == PBMoves::FLYINGPRESS
typemod2=move.pbTypeModifier(PBTypes::FLYING,attacker,opponent,zorovar)
typemod3= ((typemod*typemod2)/4.0)
typemod=typemod3
end
# Field Effect type changes go here
typemod=move.FieldTypeChange(attacker,opponent,typemod,false)
if typemod==0
if @function==0x111
return 1
end
end
return typemod
end
=begin
# Updated in Essentials
def pbAICritRate(attacker,opponent,move)
# $buffs = 0
return 0 if opponent.pbOwnSide.effects[PBEffects::LuckyChant]>0
c=0
if ((!opponent.abilitynulled && opponent.ability == PBAbilities::BATTLEARMOR) ||
(!opponent.abilitynulled && opponent.ability == PBAbilities::SHELLARMOR)) &&
!(opponent.moldbroken)
return 0
end
return 3 if (!attacker.abilitynulled && attacker.ability == PBAbilities::MERCILESS) && opponent.status == PBStatuses::POISON
c+=1 if (!attacker.abilitynulled && attacker.ability == PBAbilities::SUPERLUCK)
c+=1 if attacker.hasWorkingItem(:RAZORCLAW)
c+=1 if attacker.hasWorkingItem(:SCOPELENS)
if (attacker.species == PBSpecies::FARFETCHD) && attacker.hasWorkingItem(:STICK)
c+=2
end
if (attacker.species == PBSpecies::CHANSEY) && attacker.hasWorkingItem(:LUCKYPUNCH)
c+=2
end
return 3 if move.function==0xA0 # Frost Breath
if attacker.effects[PBEffects::LaserFocus]>0
return 3
end
c+=1 if move.hasHighCriticalRate?
c+=attacker.effects[PBEffects::FocusEnergy]
c=3 if c>3
return c
end
# Updated in Essentials
def pbRoughAccuracy(move,attacker,opponent,skill)
# Get base accuracy
baseaccuracy=move.accuracy
if skill>=PBTrainerAI.mediumSkill
if pbWeather==PBWeather::SUNNYDAY &&
(move.function==0x08 || move.function==0x15) # Thunder, Hurricane
accuracy=50
end
end
# Accuracy stages
accstage=attacker.stages[PBStats::ACCURACY]
accstage=0 if (!opponent.abilitynulled && opponent.ability == PBAbilities::UNAWARE)
accuracy=(accstage>=0) ? (accstage+3)*100.0/3 : 300.0/(3-accstage)
evastage=opponent.stages[PBStats::EVASION]
evastage-=2 if @field.effects[PBEffects::Gravity]>0
evastage=-6 if evastage<-6
evastage=0 if opponent.effects[PBEffects::Foresight] ||
opponent.effects[PBEffects::MiracleEye] ||
move.function==0xA9 || # Chip Away
(!attacker.abilitynulled && attacker.ability == PBAbilities::UNAWARE)
evasion=(evastage>=0) ? (evastage+3)*100.0/3 : 300.0/(3-evastage)
accuracy*=baseaccuracy/evasion
# Accuracy modifiers
if skill>=PBTrainerAI.mediumSkill
accuracy*=1.3 if (!attacker.abilitynulled && attacker.ability == PBAbilities::COMPOUNDEYES)
accuracy*=1.1 if (!attacker.abilitynulled && attacker.ability == PBAbilities::VICTORYSTAR)
if skill>=PBTrainerAI.highSkill
partner=attacker.pbPartner
accuracy*=1.1 if partner && (!partner.abilitynulled && partner.ability == PBAbilities::VICTORYSTAR)
end
if skill>=PBTrainerAI.highSkill
accuracy*=0.8 if (!attacker.abilitynulled && attacker.ability == PBAbilities::HUSTLE) &&
move.basedamage>0 && move.pbIsPhysical?(move.pbType(move.type,attacker,opponent))
end
if skill>=PBTrainerAI.bestSkill
accuracy/=2 if (!opponent.abilitynulled && opponent.ability == PBAbilities::WONDERSKIN) &&
move.basedamage==0 && attacker.pbIsOpposing?(opponent.index)
accuracy/=1.2 if (!opponent.abilitynulled && opponent.ability == PBAbilities::TANGLEDFEET) &&
opponent.effects[PBEffects::Confusion]>0
accuracy/=1.2 if pbWeather==PBWeather::SANDSTORM &&
(!opponent.abilitynulled && opponent.ability == PBAbilities::SANDVEIL)
accuracy/=1.2 if pbWeather==PBWeather::HAIL &&
(!opponent.abilitynulled && opponent.ability == PBAbilities::SNOWCLOAK)
end
if attacker.itemWorks?
accuracy*=1.1 if attacker.item == PBItems::WIDELENS
accuracy*=1.2 if attacker.item == PBItems::ZOOMLENS && attacker.pbSpeed<opponent.pbSpeed
if attacker.item == PBItems::MICLEBERRY
accuracy*=1.2 if ((!attacker.abilitynulled && attacker.ability == PBAbilities::GLUTTONY) &&
attacker.hp<=(attacker.totalhp/2.0).floor) ||
attacker.hp<=(attacker.totalhp/4.0).floor
end
if skill>=PBTrainerAI.highSkill
accuracy/=1.1 if opponent.item == PBItems::BRIGHTPOWDER
accuracy/=1.1 if opponent.item == PBItems::LAXINCENSE
end
end
end
# Override accuracy
accuracy=100 if move.accuracy==0 # Doesn't do accuracy check (always hits)
accuracy=100 if move.function==0xA5 # Swift
if skill>=PBTrainerAI.mediumSkill
accuracy=100 if opponent.effects[PBEffects::LockOn]>0 &&
opponent.effects[PBEffects::LockOnPos]==attacker.index
if skill>=PBTrainerAI.highSkill
accuracy=100 if (!attacker.abilitynulled && attacker.ability == PBAbilities::NOGUARD) ||
(!opponent.abilitynulled && opponent.ability == PBAbilities::NOGUARD)
end
accuracy=100 if opponent.effects[PBEffects::Telekinesis]>0
case pbWeather
when PBWeather::HAIL
accuracy=100 if move.function==0x0D # Blizzard
when PBWeather::RAINDANCE
accuracy=100 if move.function==0x08 || move.function==0x15 # Thunder, Hurricane
end
if move.function==0x70 # OHKO moves
accuracy=move.accuracy+attacker.level-opponent.level
accuracy=0 if (!opponent.abilitynulled && opponent.ability == PBAbilities::STURDY)
accuracy=0 if opponent.level>attacker.level
end
end
accuracy=100 if accuracy>100
return accuracy
end
=end
end
Reference in New Issue View Git Blame Copy Permalink