class PokeBattle_Move
attr_accessor(:id)
attr_reader(:name)
attr_reader(:battle)
attr_reader(:accuracy)
attr_reader(:basedamage)
attr_reader(:addlEffect)
attr_reader(:type)
attr_reader(:function)
attr_reader(:target)
attr_reader(:flags)
attr_reader(:thismove)
attr_accessor(:pp)
attr_accessor(:totalpp)
attr_reader(:priority)

################################
#    Constants
################################

NOTYPE = 0x01
IGNOREPKMNTYPES = 0x02
NOWEIGHTING = 0x04
NOCRITICAL = 0x08
NOREFLECT = 0x10

################################
def totalpp
 return @thismove.totalpp if @thismove
end

def to_int
 return @id
end

def ppzone
 return 3 if pp==0 # red [28,3,0], [30,27,19]
 return 2 if pp<=(totalpp/4).floor # orange [31,16,0],[31,29,14]
 return 1 if pp<=(totalpp/2).floor # yellow [26,24,0],[31,30,17]
 return 0 # black [9,9,9],[27,27,27]
end

#######################################

def PokeBattle_Move.getName(id)
 movedata=File.open("PBS/strMovesEN.dat","rb")
 movename=movedata.readName(id)
 movedata.close
 return movename 
end

#######################################

def initialize(battle,move)
 @id=move.id
 @battle=battle
 # get data on the move
 movedata=File.open("PBS/rsattacks.dat","rb")
 movedata.pos=id*9
 @function=movedata.fgetb
 @basedamage=movedata.fgetb
 @type=movedata.fgetb
 @accuracy=movedata.fgetb
 movedata.fgetb # total PP
 @pp=move.pp # can be changed with Mimic/Transform
 @addlEffect=movedata.fgetb
 @target=movedata.fgetb
 @priority=movedata.fgetsb
 @flags=movedata.fgetb
 @thismove=move
 movedata.close
 # get the move's name
 movedata=File.open("PBS/strMovesEN.dat","rb")
 @name=movedata.readName(id)
 movedata.close
end


def pbIsPhysical?(type)
 return (type<9)
end

def pbIsSpecial?(type)
 return (type>=9)
end

$PBTypeChart=[
2,2,2,2,2,1,2,0,1,2,2,2,2,2,2,2,2,
4,2,1,1,2,4,1,0,4,2,2,2,2,1,4,2,4,
2,4,2,2,2,1,4,2,1,2,2,4,1,2,2,2,2,
2,2,2,1,1,1,2,1,0,2,2,4,2,2,2,2,2,
2,2,0,4,2,4,1,2,4,4,2,1,4,2,2,2,2,
2,1,4,2,1,2,4,2,1,4,2,2,2,2,4,2,2,
2,1,1,1,2,2,2,1,1,1,2,4,2,4,2,2,4,
0,2,2,2,2,2,2,4,1,2,2,2,2,4,2,2,1,
2,2,2,2,2,4,2,2,1,1,1,2,1,2,4,2,2,
2,2,2,2,2,1,4,2,4,1,1,4,2,2,4,1,2,
2,2,2,2,4,4,2,2,2,4,1,1,2,2,2,1,2,
2,2,1,1,4,4,1,2,1,1,4,1,2,2,2,1,2,
2,2,4,2,0,2,2,2,2,2,4,1,1,2,2,1,2,
2,4,2,4,2,2,2,2,1,2,2,2,2,1,2,2,0,
2,2,4,2,4,2,2,2,1,1,1,4,2,2,1,4,2,
2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,4,2,
2,1,2,2,2,2,2,4,1,2,2,2,2,4,2,2,1
 ]


def pbTypeModifier(type,opponent)
 return 4 if type<0
 atype=type
 otype1=opponent.type1
 otype2=opponent.type2
 atype=atype-1 if atype>=10
 otype1=otype1-1 if otype1>=10
 otype2=otype2-1 if otype2>=10
 mod1=$PBTypeChart[atype*17+otype1]
 mod2=(otype1==otype2) ? 2 : $PBTypeChart[atype*17+otype2]
 if opponent.effects[PBEffects::Foresight]
  mod1=2 if otype1==PBTypes::GHOST &&
     (atype==PBTypes::NORMAL ||
     atype==PBTypes::FIGHTING)
  mod2=2 if otype2==PBTypes::GHOST &&
     (atype==PBTypes::NORMAL ||
     atype==PBTypes::FIGHTING)
 end
 return mod1*mod2
end

def pbAccuracyCheck(attacker,opponent)
 if (@flags&0x10)==0 # flag e: Accuracy check
  return true
 end 
 accuracy=@accuracy
 stagemul=[33,36,43,50,60,75,100,133,166,200,250,266,300]
 #One-hit KO accuracy handled elsewhere
 if @battle.pbWeather==PBWeather::RAINDANCE && @id==PBMoves::THUNDER
  return true
 end
 if @battle.pbWeather==PBWeather::SUNNYDAY && @id==PBMoves::THUNDER
  accuracy=50
 end
 evasion=opponent.effects[PBEffects::Foresight] ? 0 : opponent.stages[PBStats::EVASION]
 stage=attacker.stages[PBStats::ACCURACY]-evasion
 stage=-6 if stage<-6
 stage=6 if stage>6
 accuracy=(accuracy*stagemul[stage+6]/100).floor
 accuracy=(accuracy*1.3).floor if attacker.ability==PBAbilities::COMPOUNDEYES
 if @battle.pbWeather==PBWeather::SANDSTORM && opponent.ability==PBAbilities::SANDVEIL
  accuracy=(accuracy*4/5).floor
 end
 realtype=pbType(@type,attacker,opponent)
 if attacker.ability==PBAbilities::HUSTLE && pbIsPhysical?(realtype)
  accuracy=(accuracy*4/5).floor
 end
 if opponent.item==PBItems::BRIGHTPOWDER
  accuracy=(accuracy*90/100).floor
 end
 if opponent.item==PBItems::LAXINCENSE
  accuracy=(accuracy*95/100).floor
 end
 return 1+@battle.pbRandom(100)<accuracy
end

def pbTypeModMessages(type,opponent)
 return 4 if type<0
 if (opponent.ability==PBAbilities::WATERABSORB && type==PBTypes::WATER)||
   (opponent.ability==PBAbilities::VOLTABSORB && type==PBTypes::ELECTRIC)
  hpgain=(opponent.hp/4).floor
  hpgain=opponent.pbRecoverHP(hpgain)
  if hpgain==0
   @battle.pbDisplay("#{opponent.pbThis}'s ??? made #{@name} useless!")
  else
   @battle.pbDisplay("#{opponent.pbThis}'s ??? restored its HP!")
  end
  return 0
 end
 typemod=pbTypeModifier(type,opponent)
 if typemod==0
  @battle.pbDisplay("It doesn't affect #{opponent.pbThis}...");
 end
 return typemod
end

def pbTargetsAll?(attacker)
 if @target==0x08 # All opposing Pokemon
  # TODO: should apply even if partner faints during an attack
  return attacker.pbOpposing1.hp>0 && attacker.pbOpposing2.hp>0
 end
 return false
end

def pbIsCritical?(attacker,opponent)
 if opponent.ability==PBAbilities::SHELLARMOR||
    opponent.ability==PBAbilities::BATTLEARMOR
  return false
 end
 c=0
 ratios=[16,8,4,3,2]
 c=c+2 if attacker.effects[PBEffects::FocusEnergy]
 if @function==0x2B || @function==0x4B || @function==0xC8 || @function==0xD1
  c=c+1
 end
 if attacker.species==PBSpecies::CHANSEY && attacker.item==PBItems::LUCKYPUNCH
  c=c+2
 end
 if attacker.species==PBSpecies::FARFETCHD && attacker.item==PBItems::STICK
  c=c+2
 end
 c=c+1 if attacker.item==PBItems::SCOPELENS
 c=4 if c>4
 return @battle.pbRandom(ratios[c])==0
end

def pbCalcDamage(attacker,opponent,options=0)
 opponent.damagestate.critical=false
 opponent.damagestate.typemod=0
 opponent.damagestate.calcdamage=0
 opponent.damagestate.hplost=0
 if @basedamage==0
  return 0
 end
 if (options&NOCRITICAL)==0
  opponent.damagestate.critical=pbIsCritical?(attacker,opponent)
 end
 stagemul=[10,10,10,10,10,10,10,15,20,25,30,35,40]
 stagediv=[40,35,30,25,20,15,10,10,10,10,10,10,10]
 basedmg=@basedamage
 basedmg=pbBaseDamage(basedmg,attacker,opponent)
 if (options&NOTYPE)==0
  type=@type
  type=pbType(type,attacker,opponent)
 else
  type=-1 # Will be treated as physical
 end
 #Gym Badges (internal battles only)
 if @battle.internalbattle
  # Stone Badge (index 0)
  if @battle.player.badges[0] && !@battle.pbIsOpposing(attacker.index)
   atk=(atk*1.1).floor
  end
  # Balance Badge (index 4)
  if @battle.player.badges[4] && !@battle.pbIsOpposing(opponent.index)
   defense=(defense*1.1).floor
  end
  # Mind Badge (index 6)
  if @battle.player.badges[6] && !@battle.pbIsOpposing(attacker.index)
   spatk=(spatk*1.1).floor
  end
  if @battle.player.badges[6] && !@battle.pbIsOpposing(opponent.index)
   spdef=(spdef*1.1).floor
  end
 end
 #Stat Stages
 atkstage=attacker.stages[PBStats::ATTACK]+6
 spatkstage=attacker.stages[PBStats::SPATK]+6
 defstage=opponent.stages[PBStats::DEFENSE]+6
 spdefstage=opponent.stages[PBStats::SPDEF]+6
 if opponent.damagestate.critical
  atkstage=6 if atkstage>6
  spatkstage=6 if spatkstage>6
  defstage=6 if defstage<6
  spdefstage=6 if spdefstage<6
 end
 atk=(attacker.attack*stagemul[atkstage]/stagediv[atkstage]).floor
 spatk=(attacker.spatk*stagemul[spatkstage]/stagediv[spatkstage]).floor
 defense=(opponent.defense*stagemul[defstage]/stagediv[defstage]).floor
 spdef=(opponent.spdef*stagemul[spdefstage]/stagediv[spdefstage]).floor
 if opponent.ability==PBAbilities::MARVELSCALE&&opponent.status>0
  defense=(defense*1.5).floor
 end
 if @id==PBMoves::SELFDESTRUCT&&@id==PBMoves::EXPLOSION
  defense=(defense/2).floor
 end
 if opponent.species==PBSpecies::CLAMPERL&&opponent.item==PBItems::DEEPSEASCALE
  spdef*=2
 end
 if (opponent.species==PBSpecies::LATIOS||opponent.species==PBSpecies::LATIAS)&&
    opponent.item==PBItems::SOULDEW
  spdef*=2 #except in Battle Tower/Battle Frontier
 end
 if (attacker.species==PBSpecies::LATIOS||attacker.species==PBSpecies::LATIAS)&&
    attacker.item==PBItems::SOULDEW
  spatk*=2 #except in Battle Tower/Battle Frontier
 end
 if opponent.species==PBSpecies::DITTO&&opponent.item==PBItems::METALPOWDER
  defense*=2
 end
 # Type boosting items
 modatk=(atk*1.1).floor
 modspatk=(spatk*1.1).floor
 atk=modatk if attacker.item==PBItems::SILKSCARF && type==PBTypes::NORMAL
 atk=modatk if attacker.item==PBItems::BLACKBELT && type==PBTypes::FIGHTING
 atk=modatk if attacker.item==PBItems::SHARPBEAK && type==PBTypes::FLYING
 atk=modatk if attacker.item==PBItems::POISONBARB && type==PBTypes::POISON
 atk=modatk if attacker.item==PBItems::SOFTSAND && type==PBTypes::GROUND
 atk=modatk if attacker.item==PBItems::HARDSTONE && type==PBTypes::ROCK
 atk=modatk if attacker.item==PBItems::SILVERPOWDER && type==PBTypes::BUG
 atk=modatk if attacker.item==PBItems::SPELLTAG && type==PBTypes::GHOST
 atk=modatk if attacker.item==PBItems::METALCOAT && type==PBTypes::STEEL
 spatk=modspatk if attacker.item==PBItems::CHARCOAL && type==PBTypes::FIRE
 spatk=modspatk if attacker.item==PBItems::MYSTICWATER && type==PBTypes::WATER
 spatk=modspatk if attacker.item==PBItems::MIRACLESEED && type==PBTypes::GRASS
 spatk=modspatk if attacker.item==PBItems::MAGNET && type==PBTypes::ELECTRIC
 spatk=modspatk if attacker.item==PBItems::TWISTEDSPOON && type==PBTypes::PSYCHIC
 spatk=modspatk if attacker.item==PBItems::NEVERMELTICE && type==PBTypes::ICE
 spatk=modspatk if attacker.item==PBItems::DRAGONFANG && type==PBTypes::DRAGON
 spatk=modspatk if attacker.item==PBItems::BLACKGLASSES && type==PBTypes::DARK
 if attacker.item==PBItems::SEAINCENSE&&type==PBTypes::WATER
  spatk=(spatk*1.05).floor
 end
 atk=(atk*1.5).floor if attacker.item==PBItems::CHOICEBAND
 if attacker.species==PBSpecies::CLAMPERL&&attacker.item==PBItems::DEEPSEATOOTH
  spatk*=2
 end
 if attacker.species==PBSpecies::PIKACHU&&attacker.item==PBItems::LIGHTBALL
  spatk*=2
 end
 if (attacker.species==PBSpecies::CUBONE||attacker.species==PBSpecies::MAROWAK)&&
   attacker.item==PBItems::THICKCLUB
  atk*=2
 end
 atk*=2 if attacker.ability==PBAbilities::HUGEPOWER
 atk*=2 if attacker.ability==PBAbilities::PUREPOWER
 atk=(atk*1.5).floor if attacker.ability==PBAbilities::HUSTLE
 if attacker.ability==PBAbilities::GUTS && attacker.status>0
  atk=(atk*1.5).floor
 end
 if attacker.ability==PBAbilities::PLUS && @battle.pbCheckGlobalAbility(PBAbilities::MINUS)
  spatk=(spatk*1.5).floor
 end
 if attacker.ability==PBAbilities::MINUS && @battle.pbCheckGlobalAbility(PBAbilities::PLUS)
  spatk=(spatk*1.5).floor
 end
 if attacker.ability==PBAbilities::FLASHFIRE && attacker.effects[PBEffects::FlashFire] && type==PBTypes::FIRE
  basedmg=(basedmg*1.5).floor
 end
 if attacker.hp<=(attacker.hp/3).floor
  modbasedmg=(basedmg*1.5).floor
  basedmg=modbasedmg if attacker.ability==PBAbilities::OVERGROW&&type==PBTypes::GRASS
  basedmg=modbasedmg if attacker.ability==PBAbilities::BLAZE&&type==PBTypes::FIRE
  basedmg=modbasedmg if attacker.ability==PBAbilities::TORRENT&&type==PBTypes::WATER
  basedmg=modbasedmg if attacker.ability==PBAbilities::SWARM&&type==PBTypes::BUG
 end
 if type==PBTypes::ELECTRIC
  for i in 0..3
   if @battle.battlers[i].effects[PBEffects::MudSport]
    basedmg=(basedmg/2).floor
    break #Not cumulative
   end
  end
 end
 if type==PBTypes::FIRE
  for i in 0..3
   if @battle.battlers[i].effects[PBEffects::WaterSport]
    basedmg=(basedmg/2).floor
    break #Not cumulative
   end
  end
 end
 if opponent.ability==PBAbilities::THICKFAT && (type==PBTypes::ICE||type==PBTypes::FIRE)
  atk>>=1
 end
 #Damage formula
 if type>=0 && pbIsSpecial?(type)
  atk=spatk
  defense=spdef
 end
 defense=1 if defense<1
 atk=1 if atk<1
 damage=(((2*attacker.level/5+2).floor*atk*basedmg/defense).floor/50).floor
 if pbTargetsAll?(attacker)
  damage>>=1
 end
 #Weather
 weather=@battle.pbWeather
 if weather==PBWeather::SUNNYDAY
   if type==PBTypes::FIRE
    damage*=2
   elsif type==PBTypes::WATER
    damage>>=1
   end
 end
 if weather==PBWeather::RAINDANCE
   if type==PBTypes::FIRE
    damage>>=1
   elsif type==PBTypes::WATER
    damage=(damage*2)
   end
 end
 if weather==PBWeather::SANDSTORM||
   weather==PBWeather::HAIL||
   weather==PBWeather::RAINDANCE
   if @id==PBMoves::SOLARBEAM
    damage>>=1
   end
 end
 damage+=2
 if (options&IGNOREPKMNTYPES)==0
  #Same Type Attack Bonus
  if attacker.pbHasType?(type)
   damage=(damage*1.5).floor
  end
  #Type Effectiveness
  typemod=pbTypeModMessages(type,opponent)
  damage=(damage*typemod/4).floor
  opponent.damagestate.typemod=typemod
  if typemod==0
   opponent.damagestate.calcdamage=0
   return 0
  end
 else
  opponent.damagestate.typemod=4
 end
 damage=pbModifyDamage(damage,attacker,opponent)
 # Helping Hand
 if attacker.effects[PBEffects::HelpingHand]
  damage=(damage*1.5).floor
 end
 # Burns
 if attacker.status == PBStatuses::BURN && 
    attacker.ability != PBAbilities::GUTS && @id != PBMoves::FACADE
  damage=(damage/2).floor
 end
 # Charge
 if attacker.effects[PBEffects::Charge] > 0&& type==PBTypes::ELECTRIC
  damage=(damage*1.5).floor
 end
 if !opponent.damagestate.critical && (options&NOREFLECT)==0
  #Reflect
  oppside=opponent.pbOwnSide
  if oppside.effects[PBEffects::Reflect] > 0
   if opponent.pbPartner.hp>0 # if opponent has a partner [TODO: should apply even if partner faints during an attack]
    damage=(damage*2/3).floor
   else
    damage=(damage/2).floor
   end
  end
  #Light Screen
  if oppside.effects[PBEffects::LightScreen] > 0
   if opponent.pbPartner.hp>0 # if opponent has a partner [TODO: should apply even if partner faints during an attack]
    damage=(damage*2/3).floor
   else
    damage=(damage/2).floor
   end
  end
 end
 #Damage weighting
 if (options&NOWEIGHTING)==0
  random=85+@battle.pbRandom(16)
  damage=(damage*random/100).floor
 end
 if opponent.damagestate.critical
  damage*=2
 end
 damage=1 if damage<1
##########
if false
 if attacker.index==0
  return opponent.hp
 end
 if opponent.index==0
  return 0
 end
end
##########
 opponent.damagestate.calcdamage=damage
 return damage
end

def pbModifyDamage(damage,attacker,opponent)
 return damage
end

def pbReduceHPDamage(damage,attacker,opponent)
 endure=false
 if opponent.effects[PBEffects::Substitute] > 0 && (!attacker || attacker.index!=opponent.index)
  damage=opponent.effects[PBEffects::Substitute] if damage>opponent.effects[PBEffects::Substitute]
  opponent.effects[PBEffects::Substitute]-=damage
  opponent.damagestate.substitute=true
  @battle.pbDisplayPaused("The Substitute took damage for #{opponent.name}!")
  if opponent.effects[PBEffects::Substitute]==0
   @battle.pbDisplayPaused("#{opponent.name}'s Substitute faded!")
  end
  opponent.damagestate.hplost=damage
  damage=0
 else
  if damage>=opponent.hp
   damage=opponent.hp
   if opponent.effects[PBEffects::Endure]
    damage=damage-1
    opponent.damagestate.endured=true
   elsif opponent.damagestate.focusband
    opponent.damagestate.focusbandused=true
    damage=damage-1
   elsif @id==PBMoves::FALSESWIPE
    damage=damage-1
   end
   damage=0 if damage<0
  end
  oldhp=opponent.hp
  opponent.hp-=damage
  @battle.scene.pbHPChanged(opponent,oldhp)
  opponent.damagestate.hplost=damage
 end
 return damage
end

def pbEffectMessages(opponent)
 return if pbIsMultiHit
 if opponent.damagestate.critical
  @battle.pbDisplay("A critical hit!")
 end
 if opponent.damagestate.endured
  @battle.pbDisplay("#{opponent.name} endured the hit!")
 elsif opponent.damagestate.focusbandused
  @battle.pbDisplay("#{opponent.name} hung on using its Focus Band!")
 end
 if opponent.damagestate.typemod>=1&&opponent.damagestate.typemod<4
  @battle.pbDisplay("It's not very effective...")
 end
 if opponent.damagestate.typemod>4
  @battle.pbDisplay("It's super effective!")
 end
end

def pbEffectFixedDamage(damage,attacker,opponent)
 type=@type
 type=pbType(type,attacker,opponent)
 typemod=pbTypeModMessages(type,opponent)
 opponent.damagestate.critical=false
 opponent.damagestate.typemod=0
 opponent.damagestate.calcdamage=0
 opponent.damagestate.hplost=0
 if typemod!=0
  opponent.damagestate.calcdamage=damage
  opponent.damagestate.typemod=4
  damage=1 if damage<1 # HP reduced can't be less than 1
  damage=pbReduceHPDamage(damage,attacker,opponent)
  pbEffectMessages(opponent)
  pbOnDamageLost(damage,attacker,opponent)
  return damage
 end
 return 0
end

def pbOnDamageLost(damage,attacker,opponent)
 #Used by Counter/Mirror Coat/Revenge/Focus Punch/Bide
 type=@type
 type=pbType(type,attacker,opponent)
 if opponent.effects[PBEffects::Bide]
  opponent.effects[PBEffects::BideDamage]+=damage
  opponent.effects[PBEffects::BideTarget]=attacker.index
 end
 type=PBTypes::NORMAL if @id==PBMoves::HIDDENPOWER
 if pbIsPhysical?(type)
  opponent.effects[PBEffects::Counter]=damage
  opponent.effects[PBEffects::CounterTarget]=attacker.index
 end
 if pbIsSpecial?(type)
  opponent.effects[PBEffects::MirrorCoat]=damage
  opponent.effects[PBEffects::MirrorCoatTarget]=attacker.index
 end
 opponent.lastHPLost=damage # for Revenge/Focus Punch
 opponent.lastAttacker=attacker.index # for Revenge
end

def pbSuccessCheck(attacker,opponent,numtargets)
end

def pbEffect(attacker,opponent)
 return 0 if !opponent
 damage=pbCalcDamage(attacker,opponent)
 damage=pbReduceHPDamage(damage,attacker,opponent)
 pbEffectMessages(opponent)
 pbOnDamageLost(damage,attacker,opponent)
 return damage #HP lost by opponent due to attack
end

def pbDisplayUseMessage(attacker)
 # Return values:
 # -1 if the attack should exit as a failure
 # 1 if the attack should exit as a success
 # 0 if the attack should proceed its effect
 @battle.pbDisplay("#{attacker.pbThis} used #{name}!");
 return 0
end

def pbAddTarget(targets,attacker)
end

def pbTwoTurnAttack(attacker)
 return false
end

def pbOnStartUse(attacker)
 return true
end

def pbType(type,attacker,opponent)
 return type
end

def pbBaseDamage(basedmg,attacker,opponent)
 return basedmg
end

def pbNumHits
 return 1
end

def pbMoveFailed(attacker,opponent)
 return false
end

def pbIsMultiHit #not the same as pbNumHits>1
 return false
end


def pbAdditionalEffect(attacker,opponent)
end

def PokeBattle_Move.pbFromPBMove(battle,move)
 movedata=File.open("PBS/rsattacks.dat","rb")
 movedata.pos=move.id*9
 function=movedata.fgetb
 movedata.close
 moveclasses=[
  PokeBattle_Move_00,
  PokeBattle_Move_01,
  PokeBattle_Move_02,
  PokeBattle_Move_03,
  PokeBattle_Move_04,
  PokeBattle_Move_05,
  PokeBattle_Move_06,
  PokeBattle_Move_07,
  PokeBattle_Move_08,
  PokeBattle_Move_09,
  PokeBattle_Move_0A,
  PokeBattle_Move_0B,
  PokeBattle_Move_0C,
  PokeBattle_Move_0D,
  PokeBattle_Move_0E,
  PokeBattle_Move_0F,
  PokeBattle_Move_10,
  PokeBattle_Move_11,
  PokeBattle_Move_12,
  PokeBattle_Move_13,
  PokeBattle_Move_14,
  PokeBattle_Move_15,
  PokeBattle_Move_16,
  PokeBattle_Move_17,
  PokeBattle_Move_18,
  PokeBattle_Move_19,
  PokeBattle_Move_1A,
  PokeBattle_Move_1B,
  PokeBattle_Move_1C,
  PokeBattle_Move_1D,
  PokeBattle_Move_1E,
  PokeBattle_Move_1F,
  PokeBattle_Move_20,
  PokeBattle_Move_21,
  PokeBattle_Move_22,
  PokeBattle_Move_23,
  PokeBattle_Move_24,
  PokeBattle_Move_25,
  PokeBattle_Move_26,
  PokeBattle_Move_27,
  PokeBattle_Move_28,
  PokeBattle_Move_29,
  PokeBattle_Move_2A,
  PokeBattle_Move_2B,
  PokeBattle_Move_2C,
  PokeBattle_Move_2D,
  PokeBattle_Move_2E,
  PokeBattle_Move_2F,
  PokeBattle_Move_30,
  PokeBattle_Move_31,
  PokeBattle_Move_32,
  PokeBattle_Move_33,
  PokeBattle_Move_34,
  PokeBattle_Move_35,
  PokeBattle_Move_36,
  PokeBattle_Move_37,
  PokeBattle_Move_38,
  PokeBattle_Move_39,
  PokeBattle_Move_3A,
  PokeBattle_Move_3B,
  PokeBattle_Move_3C,
  PokeBattle_Move_3D,
  PokeBattle_Move_3E,
  PokeBattle_Move_3F,
  PokeBattle_Move_40,
  PokeBattle_Move_41,
  PokeBattle_Move_42,
  PokeBattle_Move_43,
  PokeBattle_Move_44,
  PokeBattle_Move_45,
  PokeBattle_Move_46,
  PokeBattle_Move_47,
  PokeBattle_Move_48,
  PokeBattle_Move_49,
  PokeBattle_Move_4A,
  PokeBattle_Move_4B,
  PokeBattle_Move_4C,
  PokeBattle_Move_4D,
  PokeBattle_Move_4E,
  PokeBattle_Move_4F,
  PokeBattle_Move_50,
  PokeBattle_Move_51,
  PokeBattle_Move_52,
  PokeBattle_Move_53,
  PokeBattle_Move_54,
  PokeBattle_Move_55,
  PokeBattle_Move_56,
  PokeBattle_Move_57,
  PokeBattle_Move_58,
  PokeBattle_Move_59,
  PokeBattle_Move_5A,
  PokeBattle_Move_5B,
  PokeBattle_Move_5C,
  PokeBattle_Move_5D,
  PokeBattle_Move_5E,
  PokeBattle_Move_5F,
  PokeBattle_Move_60,
  PokeBattle_Move_61,
  PokeBattle_Move_62,
  PokeBattle_Move_63,
  PokeBattle_Move_64,
  PokeBattle_Move_65,
  PokeBattle_Move_66,
  PokeBattle_Move_67,
  PokeBattle_Move_68,
  PokeBattle_Move_69,
  PokeBattle_Move_6A,
  PokeBattle_Move_6B,
  PokeBattle_Move_6C,
  PokeBattle_Move_6D,
  PokeBattle_Move_6E,
  PokeBattle_Move_6F,
  PokeBattle_Move_70,
  PokeBattle_Move_71,
  PokeBattle_Move_72,
  PokeBattle_Move_73,
  PokeBattle_Move_74,
  PokeBattle_Move_75,
  PokeBattle_Move_76,
  PokeBattle_Move_77,
  PokeBattle_Move_78,
  PokeBattle_Move_79,
  PokeBattle_Move_7A,
  PokeBattle_Move_7B,
  PokeBattle_Move_7C,
  PokeBattle_Move_7D,
  PokeBattle_Move_7E,
  PokeBattle_Move_7F,
  PokeBattle_Move_80,
  PokeBattle_Move_81,
  PokeBattle_Move_82,
  PokeBattle_Move_83,
  PokeBattle_Move_84,
  PokeBattle_Move_85,
  PokeBattle_Move_86,
  PokeBattle_Move_87,
  PokeBattle_Move_88,
  PokeBattle_Move_89,
  PokeBattle_Move_8A,
  PokeBattle_Move_8B,
  PokeBattle_Move_8C,
  PokeBattle_Move_8D,
  PokeBattle_Move_8E,
  PokeBattle_Move_8F,
  PokeBattle_Move_90,
  PokeBattle_Move_91,
  PokeBattle_Move_92,
  PokeBattle_Move_93,
  PokeBattle_Move_94,
  PokeBattle_Move_95,
  PokeBattle_Move_96,
  PokeBattle_Move_97,
  PokeBattle_Move_98,
  PokeBattle_Move_99,
  PokeBattle_Move_9A,
  PokeBattle_Move_9B,
  PokeBattle_Move_9C,
  PokeBattle_Move_9D,
  PokeBattle_Move_9E,
  PokeBattle_Move_9F,
  PokeBattle_Move_A0,
  PokeBattle_Move_A1,
  PokeBattle_Move_A2,
  PokeBattle_Move_A3,
  PokeBattle_Move_A4,
  PokeBattle_Move_A5,
  PokeBattle_Move_A6,
  PokeBattle_Move_A7,
  PokeBattle_Move_A8,
  PokeBattle_Move_A9,
  PokeBattle_Move_AA,
  PokeBattle_Move_AB,
  PokeBattle_Move_AC,
  PokeBattle_Move_AD,
  PokeBattle_Move_AE,
  PokeBattle_Move_AF,
  PokeBattle_Move_B0,
  PokeBattle_Move_B1,
  PokeBattle_Move_B2,
  PokeBattle_Move_B3,
  PokeBattle_Move_B4,
  PokeBattle_Move_B5,
  PokeBattle_Move_B6,
  PokeBattle_Move_B7,
  PokeBattle_Move_B8,
  PokeBattle_Move_B9,
  PokeBattle_Move_BA,
  PokeBattle_Move_BB,
  PokeBattle_Move_BC,
  PokeBattle_Move_BD,
  PokeBattle_Move_BE,
  PokeBattle_Move_BF,
  PokeBattle_Move_C0,
  PokeBattle_Move_C1,
  PokeBattle_Move_C2,
  PokeBattle_Move_C3,
  PokeBattle_Move_C4,
  PokeBattle_Move_C5,
  PokeBattle_Move_C6,
  PokeBattle_Move_C7,
  PokeBattle_Move_C8,
  PokeBattle_Move_C9,
  PokeBattle_Move_CA,
  PokeBattle_Move_CB,
  PokeBattle_Move_CC,
  PokeBattle_Move_CD,
  PokeBattle_Move_CE,
  PokeBattle_Move_CF,
  PokeBattle_Move_D0,
  PokeBattle_Move_D1,
  PokeBattle_Move_D2,
  PokeBattle_Move_D3,
  PokeBattle_Move_D4,
  PokeBattle_Move_D5
 ]
 return moveclasses[function].new(battle,move)
end


end