################################################################################
# OHKO. Accuracy increases by difference between levels of user and target.
################################################################################
class PokeBattle_Move_070 < PokeBattle_Move
  def pbAccuracyCheck(attacker,opponent)
    if !attacker.hasMoldBreaker && opponent.hasWorkingAbility(:STURDY)
      @battle.pbDisplay(_INTL("{1} was protected by {2}!",opponent.pbThis,PBAbilities.getName(opponent.ability)))  
      return false
    end
    if opponent.level>attacker.level
      @battle.pbDisplay(_INTL("{1} is unaffected!",opponent.pbThis))
      return false
    end
    @accuracy=20 if isConst?(@id,PBMoves,:SHEERCOLD) && !attacker.pbHasType?(:ICE)
    [email protected]+attacker.level-opponent.level
    return @battle.pbRandom(100)<acc
  end

  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if isConst?(@id,PBMoves,:SHEERCOLD) && opponent.pbHasType?(:ICE)
      @battle.pbDisplay(_INTL("It doesn't affect {1}...",opponent.pbThis(true)))
      return -1
    end
    damage=pbEffectFixedDamage(opponent.totalhp,attacker,opponent,hitnum,alltargets,showanimation)
    if opponent.fainted?
      @battle.pbDisplay(_INTL("It's a one-hit KO!"))
    end
    return damage
  end
end

################################################################################
# If user is KO'd before it next moves, the battler that caused it also faints.
# (Destiny Bond)
################################################################################
class PokeBattle_Move_0E7 < PokeBattle_Move  
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if @id==attacker.lastMoveUsed
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,nil,hitnum,alltargets,showanimation)
    attacker.effects[PBEffects::DestinyBond]=true
    @battle.pbDisplay(_INTL("{1} is trying to take its foe down with it!",attacker.pbThis))
    return 0
  end
end

################################################################################
# The user instructs the target to use its last move again. (Instruct)
################################################################################
class PokeBattle_Move_16B < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    blacklist=[
       0x168, # Instruct
       0x0D4, # Bide
       0x115, # Focus Punch
       0x171, # Shell Trap
       0x172, # Beak Blast
       0x05D, # Sketch
       0x069, # Transform
       0x05C, # Mimic
       0x14B, # King's Shield
       0x002, # Struggle
  #Moves that call other moves
       0x0AE, # Mirror Move
       0x0AF, # Copycat
       0x0B0, # Me First
       0x0B3, # Nature Power
       0x0B4, # Sleep Talk
       0x0B5, # Assist
       0x0B6  # Metronome
    ]
    if opponent.lastMoveUsed<=0 ||
       isConst?(PBMoveData.new(opponent.lastMoveUsed).type,PBTypes,:SHADOW) ||
       blacklist.include?(PBMoveData.new(opponent.lastMoveUsed).function) ||
       opponent.effects[PBEffects::Bide]>0 || 
       opponent.effects[PBEffects::HyperBeam]>0 || 
       opponent.effects[PBEffects::Rollout]>0 ||
       opponent.effects[PBEffects::TwoTurnAttack]>0
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    for i in opponent.moves
      if i.id==opponent.lastMoveUsed && i.id>0 && i.pp==0
        @battle.pbDisplay(_INTL("But it failed!"))
        return -1
      end      
    end
    if opponent.lastMoveUsed!=opponent.moves[0].id &&
       opponent.lastMoveUsed!=opponent.moves[1].id &&
       opponent.lastMoveUsed!=opponent.moves[2].id &&
       opponent.lastMoveUsed!=opponent.moves[3].id
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,opponent,hitnum,alltargets,showanimation)
    @battle.pbDisplay(_INTL("{1} used the move instructed by {2}!",opponent.pbThis,attacker.pbThis))
    if opponent.effects[PBEffects::Disable]>0 && opponent.lastMoveUsed==opponent.effects[PBEffects::DisableMove] ||
       opponent.effects[PBEffects::HealBlock]>0 && opponent.lastMoveUsed.isHealingMove? ||
       @battle.field.effects[PBEffects::Gravity]>0 && opponent.lastMoveUsed.unusableInGravity? ||
       opponent.effects[PBEffects::ThroatChop]>0 && opponent.lastMoveUsed.isSoundBased? ||
       opponent.effects[PBEffects::Taunt]>0 && opponent.lastMoveUsed.basedamage==0 ||
       opponent.effects[PBEffects::Imprison]
       # Won't consume PP
    else
      @battle.choices[opponent.index][2].pp-=1
    end
    opponent.pbUseMoveSimple(opponent.lastMoveUsed,-1,@battle.choices[opponent.index][3])
    return 0
  end
end

################################################################################
# If the target is an ally, heals 50% of the max HP target. If target is an 
# opponent, damages them normally. (Pollen Puff)
################################################################################
class PokeBattle_Move_16F < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if opponent.hasWorkingAbility(:BULLETPROOF)      
      PBDebug.log("[Ability triggered] #{opponent.pbThis}'s Bulletproof (made #{@name} ineffective)")
      @battle.pbDisplay(_INTL("{1}'s {2} made {3} ineffective!",
         opponent.pbThis,PBAbilities.getName(opponent.ability),@name))
      return -1
    end
    if attacker.pbPartner == opponent
      if opponent.effects[PBEffects::HealBlock]>0
        @battle.pbDisplay(_INTL("But it failed!"))
        return -1
      elsif opponent.hp==opponent.totalhp
        @battle.pbDisplay(_INTL("{1}'s HP is full!",opponent.pbThis))
        return -1
      end
      pbShowAnimation(@id,attacker,opponent,hitnum,alltargets,showanimation)
      opponent.pbRecoverHP(((opponent.totalhp)/2).floor,true)
      @battle.pbDisplay(_INTL("{1}'s HP was restored.",opponent.pbThis))
      return 0     
    else      
      return super(attacker,opponent,hitnum,alltargets,showanimation)
    end
  end
end

Pokémon affected by Heal Block cannot target allies with Pollen Puff (but they can target an opponent);

  def pbChooseTarget(index,targettype)
    pbShowWindow(FIGHTBOX)
    cw = @sprites["fightwindow"]
    [email protected][index]
    cw.battler=battler
    [email protected][index]
    if battler.moves[lastIndex].id!=0
      cw.setIndex(lastIndex)
    else
      cw.setIndex(0)
    end
    curwindow=pbFirstTarget(index,targettype)
    if curwindow==-1
      raise RuntimeError.new(_INTL("No targets somehow..."))
    end
    loop do
      pbGraphicsUpdate
      pbInputUpdate
      pbUpdateSelected(curwindow)
      if Input.trigger?(Input::B)
        pbUpdateSelected(-1)
        return -1
      elsif Input.trigger?(Input::C)
        pbUpdateSelected(-1)
        return curwindow
      end
      if curwindow>=0
        if Input.trigger?(Input::RIGHT) || Input.trigger?(Input::DOWN)
          loop do
            case targettype
            when PBTargets::SingleNonUser
              case curwindow
              when 0; newcurwindow=2
              when 1; newcurwindow=0
              when 2; newcurwindow=3
              when 3; newcurwindow=1
              end
            when PBTargets::UserOrPartner
              newcurwindow=(curwindow+2)%4
            end
            curwindow=newcurwindow
            next if targettype==PBTargets::SingleNonUser && curwindow==index
            next if targettype==PBTargets::SingleNonUser && curwindow==(index+2)%4 &&
                    @battle.battlers[curwindow].effects[PBEffects::HealBlock]>0 &&
                    battler.moves[lastIndex].function==0x16F # Pollen Puff
            break if [email protected][curwindow].fainted?
          end
        elsif Input.trigger?(Input::LEFT) || Input.trigger?(Input::UP)
          loop do 
            case targettype
            when PBTargets::SingleNonUser
              case curwindow
              when 0; newcurwindow=1
              when 1; newcurwindow=3
              when 2; newcurwindow=0
              when 3; newcurwindow=2
              end
            when PBTargets::UserOrPartner
              newcurwindow=(curwindow+2)%4
            end
            curwindow=newcurwindow
            next if targettype==PBTargets::SingleNonUser && curwindow==index
            next if targettype==PBTargets::SingleNonUser && curwindow==(index+2)%4 &&
                    @battle.battlers[curwindow].effects[PBEffects::HealBlock]>0 &&
                    battler.moves[lastIndex].function==0x16F # Pollen Puff
            break if [email protected][curwindow].fainted?
          end
        end
      end
    end
  end

    Yawn               = 108
    RagePowder         = 109

    @effects[PBEffects::FollowMe]         = 0
    @effects[PBEffects::RagePowder]       = 0
    @effects[PBEffects::Foresight]        = false

    # Change target to user of Follow Me/Rage Powder (overrides Magic Coat
    # because check for Magic Coat below uses this target)
    if PBTargets.targetsOneOpponent?(thismove)
      newtarget=nil; strength=100
      for i in priority # use Pokémon latest in priority
        next if !user.pbIsOpposing?(i.index)
        if !i.fainted? && [email protected] && !i.effects[PBEffects::SkyDrop]
          if i.effects[PBEffects::FollowMe]>0 && i.effects[PBEffects::FollowMe]<strength
            PBDebug.log("[Lingering effect triggered] #{i.pbThis}'s Follow Me")
            newtarget=i; strength=i.effects[PBEffects::FollowMe]; changeeffect=0
          elsif i.effects[PBEffects::RagePowder]>0 && i.effects[PBEffects::RagePowder]<strength &&
                !(user.hasWorkingItem(:SAFETYGOGGLES) || user.pbHasType?(:GRASS) || user.hasWorkingAbility(:OVERCOAT))
            PBDebug.log("[Lingering effect triggered] #{i.pbThis}'s Rage Powder")
            newtarget=i; strength=i.effects[PBEffects::RagePowder]; changeeffect=0
          end
        end        
      end
      target=newtarget if newtarget
    end

################################################################################
# This round, user becomes the target of attacks that have single targets.
# (Follow Me, Rage Powder)
################################################################################
class PokeBattle_Move_117 < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if [email protected]
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,nil,hitnum,alltargets,showanimation)
    if isConst?(@id,PBMoves,:FOLLOWME)
      attacker.effects[PBEffects::FollowMe]=1
      if !attacker.pbPartner.fainted? && attacker.pbPartner.effects[PBEffects::FollowMe]>0
        attacker.effects[PBEffects::FollowMe]=attacker.pbPartner.effects[PBEffects::FollowMe]+1
      end
    elsif isConst?(@id,PBMoves,:RAGEPOWDER)
      attacker.effects[PBEffects::RagePowder]=1
      if !attacker.pbPartner.fainted? && attacker.pbPartner.effects[PBEffects::RagePowder]>0
        attacker.effects[PBEffects::RagePowder]=attacker.pbPartner.effects[PBEffects::RagePowder]+1
      end
    end
    @battle.pbDisplay(_INTL("{1} became the center of attention!",attacker.pbThis))
    return 0
  end
end

    # Healing Wish/Lunar Dance - should go here
    # Spikes/Toxic Spikes/Stealth Rock - should go here (in order of their 1st use)
    for i in 0...4
      if @battlers[i].turncount>0 && @battlers[i].hasWorkingAbility(:TRUANT)
        @battlers[i].effects[PBEffects::Truant][email protected][i].effects[PBEffects::Truant]
      end
      if @battlers[i].effects[PBEffects::LockOn]>0   # Also Mind Reader
        @battlers[i].effects[PBEffects::LockOn]-=1
        @battlers[i].effects[PBEffects::LockOnPos]=-1 if @battlers[i].effects[PBEffects::LockOn]==0
      end
      @battlers[i].effects[PBEffects::Flinch]=false
      @battlers[i].effects[PBEffects::FollowMe]=0
      @battlers[i].effects[PBEffects::RagePowder]=0
      @battlers[i].effects[PBEffects::HelpingHand]=false

    Yawn               = 108
    Spotlight          = 109

    @effects[PBEffects::FollowMe]         = 0
    @effects[PBEffects::Spotlight]        = false
    @effects[PBEffects::Foresight]        = false

    # Change target to user of Follow Me (overrides Magic Coat
    # because check for Magic Coat below uses this target)
    if PBTargets.targetsOneOpponent?(thismove)
      newtarget=nil; strength=100
      for i in priority # use Pokémon latest in priority
        next if !user.pbIsOpposing?(i.index)
        if !i.fainted? && [email protected] && !i.effects[PBEffects::SkyDrop] &&
           i.effects[PBEffects::FollowMe]>0 && i.effects[PBEffects::FollowMe]<strength
          PBDebug.log("[Lingering effect triggered] #{i.pbThis}'s Follow Me")
          newtarget=i; strength=i.effects[PBEffects::FollowMe]
          changeeffect=0
        end
      end
      target=newtarget if newtarget
    end
    # Change target to target of Spotlight (overrides Magic Coat
    # because check for Magic Coat below uses this target)
    if PBTargets.targetsOneOpponent?(thismove)
      newtarget=nil
      for i in priority # use Pokémon latest in priority
        next if !user.pbIsOpposing?(i.index)
        if i.effects[PBEffects::Spotlight] && !i.fainted?
          PBDebug.log("[Lingering effect triggered] #{i.pbThis}'s Spotlight")
          newtarget=i
          changeeffect=0
        end
      end
      target=newtarget if newtarget
    end
    # TODO: Pressure here is incorrect if Magic Coat redirects target

################################################################################
# This round, target becomes the target of attacks that have single targets.
# (Spotlight)
################################################################################
class PokeBattle_Move_16A < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if [email protected]
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,nil,hitnum,alltargets,showanimation)
    opponent.effects[PBEffects::Spotlight]=true
    @battle.pbDisplay(_INTL("{1} became the center of attention!",opponent.pbThis))
    return 0
  end
end

    # Healing Wish/Lunar Dance - should go here
    # Spikes/Toxic Spikes/Stealth Rock - should go here (in order of their 1st use)
    for i in 0...4
      if @battlers[i].turncount>0 && @battlers[i].hasWorkingAbility(:TRUANT)
        @battlers[i].effects[PBEffects::Truant][email protected][i].effects[PBEffects::Truant]
      end
      if @battlers[i].effects[PBEffects::LockOn]>0   # Also Mind Reader
        @battlers[i].effects[PBEffects::LockOn]-=1
        @battlers[i].effects[PBEffects::LockOnPos]=-1 if @battlers[i].effects[PBEffects::LockOn]==0
      end
      @battlers[i].effects[PBEffects::Flinch]=false
      @battlers[i].effects[PBEffects::FollowMe]=0
      @battlers[i].effects[PBEffects::Spotlight]=false
      @battlers[i].effects[PBEffects::HelpingHand]=false

XXX,BURNUP,Burn Up,162,130,FIRE,Special,100,5,0,00,0,befg,"To inflict massive damage, the user burns itself out."

    Yawn               = 108
    BurnUp             = 109

    @effects[PBEffects::Yawn]             = 0
    @effects[PBEffects::BurnUp]           = false

    # Protean
    if user.hasWorkingAbility(:PROTEAN) &&
       thismove.function!=0xAE && # Mirror Move
       thismove.function!=0xAF && # Copycat
       thismove.function!=0xB0 && # Me First
       thismove.function!=0xB3 && # Nature Power
       thismove.function!=0xB4 && # Sleep Talk
       thismove.function!=0xB5 && # Assist
       thismove.function!=0xB6    # Metronome
      movetype=thismove.pbType(thismove.type,user,nil)
      typeless=false
      typeless=true if !user.pbHasType?(:FIRE) && thismove.function==0x162 # Burn Up
      if !typeless
        if !user.pbHasType?(movetype)
          typename=PBTypes.getName(movetype)
          PBDebug.log("[Ability triggered] #{pbThis}'s Protean made it #{typename}-type")
          user.type1=movetype
          user.type2=movetype
          user.effects[PBEffects::Type3]=-1
          user.effects[PBEffects::BurnUp]=false
          @battle.pbDisplay(_INTL("{1} transformed into the {2} type!",user.pbThis,typename))  
        end
      end
    end

    # Roost
    if isConst?(otype1,PBTypes,:FLYING) && opponent.effects[PBEffects::Roost]
      if isConst?(otype2,PBTypes,:FLYING) && isConst?(otype3,PBTypes,:FLYING)
        otype1=getConst(PBTypes,:NORMAL) || 0
      else
        otype1=otype2
      end
    end
    if isConst?(otype2,PBTypes,:FLYING) && opponent.effects[PBEffects::Roost]
      otype2=otype1
    end
    # Burn Up
    if isConst?(otype1,PBTypes,:FIRE) && opponent.effects[PBEffects::BurnUp]
      if isConst?(otype2,PBTypes,:FIRE)
        otype1=getConst(PBTypes,:QMARKS)
      else
        otype1=otype2
      end
    end
    if isConst?(otype2,PBTypes,:FIRE) && opponent.effects[PBEffects::BurnUp]
      otype2=otype1
    end    
    # Get effectivenesses

################################################################################
# After attacking, the user removes this move's type from their own typing.
# This move cannot be used for a Pokemon for which the move isn't STAB (Burn Up)
################################################################################
class PokeBattle_Move_162 < PokeBattle_Move
  def pbMoveFailed(attacker,opponent)
    return !(attacker.pbHasType?(:FIRE))
  end
    
  def pbEffectAfterHit(attacker,opponent,turneffects)
    if !attacker.fainted?
      attacker.effects[PBEffects::BurnUp]=true
      @battle.pbDisplay(_INTL("{1} burned itself out!",attacker.pbThis))
    end
  end
end

################################################################################
# User copes target's types. (Reflect Type)
################################################################################
class PokeBattle_Move_062 < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    if isConst?(attacker.ability,PBAbilities,:MULTITYPE)
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    if attacker.pbHasType?(opponent.type1) &&
       attacker.pbHasType?(opponent.type2) &&
       attacker.pbHasType?(opponent.effects[PBEffects::Type3]) &&
       opponent.pbHasType?(attacker.type1) &&
       opponent.pbHasType?(attacker.type2) &&
       opponent.pbHasType?(attacker.effects[PBEffects::Type3])
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,opponent,hitnum,alltargets,showanimation)
    attacker.type1=opponent.type1
    attacker.type2=opponent.type2
    attacker.effects[PBEffects::Type3]=-1
    @battle.pbDisplay(_INTL("{1}'s type changed to match {2}'s!",attacker.pbThis,opponent.pbThis(true)))
    attacker.effects[PBEffects::BurnUp]=false
    return 0
  end
end

    # Roost
    if isConst?(otype1,PBTypes,:FLYING) && opponent.effects[PBEffects::Roost]
      if isConst?(otype2,PBTypes,:FLYING) && isConst?(otype3,PBTypes,:FLYING)
        otype1=getConst(PBTypes,:NORMAL) || 0
      else
        otype1=otype2
      end
    end
    if isConst?(otype2,PBTypes,:FLYING) && opponent.effects[PBEffects::Roost]
      otype2=otype1
    end
    # Burn Up
    if isConst?(otype1,PBTypes,:FIRE) && opponent.effects[PBEffects::BurnUp]
      if isConst?(otype2,PBTypes,:FIRE) && isConst?(otype3,PBTypes,:FIRE)
        otype1=getConst(PBTypes,:QMARKS)
      else
        otype1=otype2
      end
    end
    if isConst?(otype2,PBTypes,:FIRE) && opponent.effects[PBEffects::BurnUp]
      otype2=otype1
    end    
    # Get effectivenesses

    p=thismove.priority
    if USENEWBATTLEMECHANICS
      p+=1 if user.hasWorkingAbility(:PRANKSTER) && thismove.pbIsStatus?
      p+=1 if user.hasWorkingAbility(:GALEWINGS) && isConst?(thismove.type,PBTypes,:FLYING)
	  
	 etc etc

    if p>0 
      for i in 0...4
	    [email protected][i]
        if user.hasWorkingAbility(:PRANKSTER) && thismove.pbIsStatus? &&
           pbIsOpposing?(i) && target.pbHasType?(:DARK) &&
          thismove.target!=PBTargets::BothSides && thismove.target!=PBTargets::OpposingSide
          @battle.pbDisplay(_INTL("It doesn't affect\r\n{1}...",target.pbThis(true)))
          PBDebug.log("[Move failed] Type immunity")
          return false
        end
      end
    end
    #if target.pbOwnSide.effects[PBEffects::QuickGuard] && thismove.canProtectAgainst? && # Reference

################################################################################
# All current battlers will perish after 3 more rounds. (Perish Song)
################################################################################
class PokeBattle_Move_0E5 < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    failed=true
    for i in 0...4
      if @battle.battlers[i].effects[PBEffects::PerishSong]==0 &&
         (attacker.hasMoldBreaker ||
         [email protected][i].hasWorkingAbility(:SOUNDPROOF))
        failed=false; break
      end
    end
    if failed
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    pbShowAnimation(@id,attacker,nil,hitnum,alltargets,showanimation)
    @battle.pbDisplay(_INTL("All Pokémon that hear the song will faint in three turns!"))
    for i in 0...4
      if @battle.battlers[i].effects[PBEffects::PerishSong]==0
        if !attacker.hasMoldBreaker && @battle.battlers[i].hasWorkingAbility(:SOUNDPROOF)
          @battle.pbDisplay(_INTL("{1}'s {2} blocks {3}!",@battle.battlers[i].pbThis,
             PBAbilities.getName(@battle.battlers[i].ability),@name))
        else
          if attacker.hasWorkingAbility(:PRANKSTER) && attacker.pbIsOpposing?(i) && 
             @battle.battlers[i].pbHasType?(:DARK)
            @battle.pbDisplay(_INTL("It doesn't affect\r\n{1}...",@battle.battlers[i].pbThis(true)))
          else
            @battle.battlers[i].effects[PBEffects::PerishSong]=4
            @battle.battlers[i].effects[PBEffects::PerishSongUser]=attacker.index
          end
        end
      end
    end
    return 0
  end
end

################################################################################
# Increases the Attack and Special Attack of all Grass-type Pokémon on the field
# by 1 stage each. Doesn't affect airborne Pokémon. (Rototiller)
################################################################################
class PokeBattle_Move_13E < PokeBattle_Move
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    didsomething=false
    for i in [attacker,attacker.pbPartner,attacker.pbOpposing1,attacker.pbOpposing2]
      next if !i || i.fainted?
      next if !i.pbHasType?(:GRASS)
      next if i.isAirborne?(attacker.hasMoldBreaker)
      next if !i.pbCanIncreaseStatStage?(PBStats::ATTACK,attacker,false,self) &&
              !i.pbCanIncreaseStatStage?(PBStats::SPATK,attacker,false,self)
      if attacker.hasWorkingAbility(:PRANKSTER) && i!=attacker.pbPartner && i.pbHasType?(:DARK)
        @battle.pbDisplay(_INTL("It doesn't affect\r\n{1}...",i.pbThis(true)))
        next
      end
      pbShowAnimation(@id,attacker,nil,hitnum,alltargets,showanimation) if !didsomething
      didsomething=true
      showanim=true
      if i.pbCanIncreaseStatStage?(PBStats::ATTACK,attacker,false,self)
        i.pbIncreaseStat(PBStats::ATTACK,1,attacker,false,self,showanim)
        showanim=false
      end
      if i.pbCanIncreaseStatStage?(PBStats::SPATK,attacker,false,self)
        i.pbIncreaseStat(PBStats::SPATK,1,attacker,false,self,showanim)
        showanim=false
      end
    end
    if !didsomething
      @battle.pbDisplay(_INTL("But it failed!"))
      return -1
    end
    return 0
  end
end

################################################################################
# Steals opponent's stat boosts before doing damage. (Spectral Thief)
################################################################################
class PokeBattle_Move_15D < PokeBattle_Move   
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    showanim=true
    for i in [PBStats::ATTACK,PBStats::DEFENSE,PBStats::SPATK,PBStats::SPDEF,
              PBStats::SPEED,PBStats::ACCURACY,PBStats::EVASION]
      if opponent.stages[i] > 0
        if attacker.pbCanIncreaseStatStage?(i,attacker,false,self)
          @battle.pbDisplay(_INTL("{1} stole the target's boosted stat!",attacker.pbThis)) if showanim
          attacker.pbIncreaseStat(i,opponent.stages[i],attacker,false,self,showanim)
          showanim=false
        end
        opponent.stages[i] = 0
      end
    end
    super(attacker,opponent,hitnum,alltargets,showanimation)
  end
end

################################################################################
#  The user's type determines the type of this move. (Revelation Dance)
################################################################################
class PokeBattle_Move_169 < PokeBattle_Move
  def pbModifyType(type,attacker,opponent)
    type=getConst(PBTypes,:NORMAL) || 0
    case attacker.type1
    when PBTypes::FIGHTING
      type=(getConst(PBTypes,:FIGHTING) || type)
    when PBTypes::FLYING
      type=(getConst(PBTypes,:FLYING) || type)
    when PBTypes::POISON
      type=(getConst(PBTypes,:POISON) || type)
    when PBTypes::GROUND
      type=(getConst(PBTypes,:GROUND) || type)
    when PBTypes::ROCK
      type=(getConst(PBTypes,:ROCK) || type)
    when PBTypes::BUG
      type=(getConst(PBTypes,:BUG) || type)
    when PBTypes::GHOST
      type=(getConst(PBTypes,:GHOST) || type)
    when PBTypes::STEEL
      type=(getConst(PBTypes,:STEEL) || type)
    when PBTypes::FIRE
      type=(getConst(PBTypes,:FIRE) || type)
    when PBTypes::QMARKS
      type=(getConst(PBTypes,:QMARKS) || type)
    when PBTypes::WATER
      type=(getConst(PBTypes,:WATER) || type)
    when PBTypes::GRASS
      type=(getConst(PBTypes,:GRASS) || type)
    when PBTypes::ELECTRIC
      type=(getConst(PBTypes,:ELECTRIC) || type)
    when PBTypes::PSYCHIC
      type=(getConst(PBTypes,:PSYCHIC) || type)
    when PBTypes::ICE
      type=(getConst(PBTypes,:ICE) || type)
    when PBTypes::DRAGON
      type=(getConst(PBTypes,:DRAGON) || type)
    when PBTypes::DARK
      type=(getConst(PBTypes,:DARK) || type)
    when PBTypes::FAIRY
      type=(getConst(PBTypes,:FAIRY) || type)
    end
    return type
  end
end

xxx,MINDBLOWN,Mind Blown,1CF,150,FIRE,Special,100,5,0,00,0,bef,"The user attacks everything around it by causing its own head to explode. This also damages the user."

################################################################################
# User takes recoil damage equal to 1/2 of the damage this move dealt.
# (Mind Blown)
################################################################################
class PokeBattle_Move_1CF < PokeBattle_Move
  def pbOnStartUse(attacker)
    if !attacker.hasMoldBreaker
      [email protected](:DAMP)
      if bearer!=nil
          @battle.pbDisplay(_INTL("{1}'s {2} prevents {3} from using {4}!",
             bearer.pbThis,PBAbilities.getName(bearer.ability),attacker.pbThis(true),@name))
        end
        return false
      end
    end
    return true
  end

  def pbEffectAfterHit(attacker,opponent,turneffects)
    if !attacker.fainted?
      if !attacker.hasWorkingAbility(:MAGICGUARD)
        attacker.pbReduceHP((attacker.totalhp/2.0).round)
      end
    end
  end
end

    Yawn               = 108
    SpeciesTransform   = 109
    FormTransform      = 110

    @effects[PBEffects::Transform]        = false
    @effects[PBEffects::SpeciesTransform] = 0
    @effects[PBEffects::FormTransform]    = 0

    # Imposter
    if self.hasWorkingAbility(:IMPOSTER) && [email protected][PBEffects::Transform] && onactive
      choice=pbOppositeOpposing
      blacklist=[
         0xC9,    # Fly
         0xCA,    # Dig
         0xCB,    # Dive
         0xCC,    # Bounce
         0xCD,    # Shadow Force
         0xCE,    # Sky Drop
         0x14D    # Phantom Force
      ]
      if choice.effects[PBEffects::Transform] ||
         choice.effects[PBEffects::Illusion] ||
         choice.effects[PBEffects::Substitute]>0 ||
         choice.effects[PBEffects::SkyDrop] ||
         blacklist.include?(PBMoveData.new(choice.effects[PBEffects::TwoTurnAttack]).function)
        PBDebug.log("[Ability triggered] #{pbThis}'s Imposter couldn't transform")
      else
        PBDebug.log("[Ability triggered] #{pbThis}'s Imposter")
        @battle.pbAnimation(getConst(PBMoves,:TRANSFORM),self,choice)
        @effects[PBEffects::Transform]=true
        @effects[PBEffects::SpeciesTransform]=choice.species
        @effects[PBEffects::FormTransform]=choice.form
        if isConst?(choice.type1,PBTypes,:QMARKS)
          @type1=getConst(PBTypes,:NORMAL)
        else
          @type1=choice.type1
          @type2=choice.type2
        end
        @effects[PBEffects::Type3]=-1
        @ability=choice.ability
        @attack=choice.attack
        @defense=choice.defense
        @speed=choice.speed
        @spatk=choice.spatk
        @spdef=choice.spdef
        for i in [PBStats::ATTACK,PBStats::DEFENSE,PBStats::SPEED,
                  PBStats::SPATK,PBStats::SPDEF,PBStats::ACCURACY,PBStats::EVASION]
          @stages[i]=choice.stages[i]
        end
        for i in 0...4
          @moves[i]=PokeBattle_Move.pbFromPBMove(@battle,PBMove.new(choice.moves[i].id))
          @moves[i].pp=5
          @moves[i].totalpp=5
        end
        @effects[PBEffects::Disable]=0
        @effects[PBEffects::DisableMove]=0
        @battle.pbDisplay(_INTL("{1} transformed into {2}!",pbThis,choice.pbThis(true)))
        PBDebug.log("[Pokémon transformed] #{pbThis} transformed into #{choice.pbThis(true)}")
      end
    end

################################################################################
# Puts the target to sleep.
################################################################################
class PokeBattle_Move_003 < PokeBattle_Move
  def pbOnStartUse(attacker)
    if isConst?(@id,PBMoves,:DARKVOID) 
      if (isConst?(attacker.species,PBSpecies,:DARKRAI) ||
          isConst?(attacker.effects[PBEffects::SpeciesTransform],PBSpecies,:DARKRAI))
        return true
      else
        @battle.pbDisplay(_INTL("But {1} can't use the move!",attacker.pbThis(true)))
        return false
      end
    else
      return true
    end    
  end  
  
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    return super(attacker,opponent,hitnum,alltargets,showanimation) if pbIsDamaging?      
    return -1 if pbTypeImmunityByAbility(pbType(@type,attacker,opponent),attacker,opponent)
    if opponent.pbCanSleep?(attacker,true,self)
      pbShowAnimation(@id,attacker,opponent,hitnum,alltargets,showanimation)
      opponent.pbSleep
      return 0
    end
    return -1
  end

  def pbAdditionalEffect(attacker,opponent)
    return if opponent.damagestate.substitute
    if opponent.pbCanSleep?(attacker,false,self)
      opponent.pbSleep
    end
  end

  def pbEffectAfterHit(attacker,opponent,turneffects)
    if isConst?(@id,PBMoves,:RELICSONG)
      if isConst?(attacker.species,PBSpecies,:MELOETTA) &&
         !attacker.effects[PBEffects::Transform] &&
         !(attacker.hasWorkingAbility(:SHEERFORCE) && self.addlEffect>0) &&
         !attacker.fainted?
        attacker.form=(attacker.form+1)%2
        attacker.pbUpdate(true)
        @battle.scene.pbChangePokemon(attacker,attacker.pokemon)
        @battle.pbDisplay(_INTL("{1} transformed!",attacker.pbThis))
        PBDebug.log("[Form changed] #{attacker.pbThis} changed to form #{attacker.form}")
      end
    end
  end
end

################################################################################
# Decreases the user's Defense by 1 stage. Always hits. (Hyperspace Fury)
################################################################################
class PokeBattle_Move_13B < PokeBattle_Move
  def pbOnStartUse(attacker)
    if isConst?(attacker.species,PBSpecies,:HOOPA) && attacker.form!=0 ||
       isConst?(attacker.effects[PBEffects::SpeciesTransform],PBSpecies,:HOOPA) &&
       attacker.effects[PBEffects::FormTransform]==1
      return true
    else
      if isConst?(attacker.species,PBSpecies,:HOOPA) && attacker.form!=1 ||
         isConst?(attacker.effects[PBEffects::SpeciesTransform],PBSpecies,:HOOPA) &&
         attacker.effects[PBEffects::FormTransform]==0
        @battle.pbDisplay(_INTL("But {1} can't use it the way it is now!",attacker.pbThis(true)))
      else
        @battle.pbDisplay(_INTL("But {1} can't use the move!",attacker.pbThis(true)))
      end
      return false
    end
  end  

  def pbAccuracyCheck(attacker,opponent)
    return true
  end
  
  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    ret=super(attacker,opponent,hitnum,alltargets,showanimation)
    if opponent.damagestate.calcdamage>0
      if attacker.pbCanReduceStatStage?(PBStats::DEFENSE,attacker,false,self)
        attacker.pbReduceStat(PBStats::DEFENSE,1,attacker,false,self)
      end
    end
    return ret
  end
end

class PokeBattle_RealBattlePeer
  def pbOnEnteringBattle(battle,pokemon)
    f=MultipleForms.call("getFormOnEnteringBattle",pokemon)
    if f
      pokemon.form=f
    end
  end
  def pbOnEndingBattle(battle,pokemon)
    f=MultipleForms.call("getFormOnEndingBattle",pokemon)
    if f
      pokemon.form=f
    end
  end
end

MultipleForms.register(:BURMY,{
"getFormOnEndingBattle"=>proc{|pokemon|
   env=pbGetEnvironment()
   if !pbGetMetadata($game_map.map_id,MetadataOutdoor)
     next 2 # Trash Cloak
   elsif env==PBEnvironment::Sand || env==PBEnvironment::Rock || env==PBEnvironment::Cave
     next 1 # Sandy Cloak
   else
     next 0 # Plant Cloak
   end
}
})


MultipleForms.register(:WORMADAM,{
"getMoveCompatibility"=>proc{|pokemon|
   next if pokemon.form==0
   movelist=[]
   case pokemon.form
   when 1; movelist=[# TMs
                     :TOXIC,:VENOSHOCK,:HIDDENPOWER,:SUNNYDAY,:HYPERBEAM,
                     :PROTECT,:RAINDANCE,:SAFEGUARD,:FRUSTRATION,:EARTHQUAKE,
                     :RETURN,:DIG,:PSYCHIC,:SHADOWBALL,:DOUBLETEAM,
                     :SANDSTORM,:ROCKTOMB,:FACADE,:REST,:ATTRACT,
                     :THIEF,:ROUND,:GIGAIMPACT,:FLASH,:STRUGGLEBUG,
                     :PSYCHUP,:BULLDOZE,:DREAMEATER,:SWAGGER,:SUBSTITUTE,
                     # Move Tutors
                     :BUGBITE,:EARTHPOWER,:ELECTROWEB,:ENDEAVOR,:MUDSLAP,
                     :SIGNALBEAM,:SKILLSWAP,:SLEEPTALK,:SNORE,:STEALTHROCK,
                     :STRINGSHOT,:SUCKERPUNCH,:UPROAR]
   when 2; movelist=[# TMs
                     :TOXIC,:VENOSHOCK,:HIDDENPOWER,:SUNNYDAY,:HYPERBEAM,
                     :PROTECT,:RAINDANCE,:SAFEGUARD,:FRUSTRATION,:RETURN,
                     :PSYCHIC,:SHADOWBALL,:DOUBLETEAM,:FACADE,:REST,
                     :ATTRACT,:THIEF,:ROUND,:GIGAIMPACT,:FLASH,
                     :GYROBALL,:STRUGGLEBUG,:PSYCHUP,:DREAMEATER,:SWAGGER,
                     :SUBSTITUTE,:FLASHCANNON,
                     # Move Tutors
                     :BUGBITE,:ELECTROWEB,:ENDEAVOR,:GUNKSHOT,:IRONDEFENSE,
                     :IRONHEAD,:MAGNETRISE,:SIGNALBEAM,:SKILLSWAP,:SLEEPTALK,
                     :SNORE,:STEALTHROCK,:STRINGSHOT,:SUCKERPUNCH,:UPROAR]
   end
   for i in 0...movelist.length
     movelist[i]=getConst(PBMoves,movelist[i])
   end
   next movelist
}
})

  def pbOnEndingBattle(battle,pokemon)
  end

  def pbStorePokemon(player,pokemon)

    for i in $Trainer.party
      @peer.pbOnEndingBattle(self,i)
      i.setItem(i.itemInitial)
      i.itemInitial=i.itemRecycle=0
      i.belch=false
    end

        elsif thismove.function==0x10B   # Hi Jump Kick, Jump Kick
          if !user.hasWorkingAbility(:MAGICGUARD)
            PBDebug.log("[Move effect triggered] #{user.pbThis} took crash damage")
            # TODO: Not shown if message is "It doesn't affect XXX..."
            @battle.pbDisplay(_INTL("{1} kept going and crashed!",user.pbThis))
            damage=(user.totalhp/2).floor
            if damage>0
              @battle.scene.pbDamageAnimation(user,0)
              user.pbReduceHP(damage)
            end
            user.pbFaint if user.fainted?
          end
        elsif thismove.function==0x170   # Mind Blown
          if !user.hasWorkingAbility(:MAGICGUARD)
            PBDebug.log("[Move effect triggered] #{user.pbThis} took damage")
            user.pbReduceHP((user.totalhp/2).round)
            user.pbFaint if user.fainted?
          end
        end
        user.effects[PBEffects::Outrage]=0 if thismove.function==0xD2 # Outrage

    # Primordial Sea, Desolate Land
    if thismove.pbIsDamaging?
      case @battle.pbWeather
      when PBWeather::HEAVYRAIN
        if isConst?(thismove.pbType(thismove.type,user,nil),PBTypes,:FIRE)
          PBDebug.log("[Move failed] Primordial Sea's rain cancelled the Fire-type #{thismove.name}")
          @battle.pbDisplay(_INTL("The Fire-type attack fizzled out in the heavy rain!"))
          user.effects[PBEffects::StompingTantrum]=true
          user.lastMoveFailed=thismove.id
          user.lastMoveUsed=thismove.id
          user.lastMoveUsedType=thismove.pbType(thismove.type,user,nil)
          if !turneffects[PBEffects::SpecialUsage]
            user.lastMoveUsedSketch=thismove.id if user.effects[PBEffects::TwoTurnAttack]==0
            user.lastRegularMoveUsed=thismove.id
          end
          @battle.lastMoveUsed=thismove.id
          @battle.lastMoveUser=user.index
          if thismove.function==0x170 # Mind Blown
            if !user.hasWorkingAbility(:MAGICGUARD)
              user.pbReduceHP((user.totalhp/2.0).round)
              user.pbFaint if user.fainted?
            end
          end
          return
        end
      when PBWeather::HARSHSUN

    # Powder
    if user.effects[PBEffects::Powder] && isConst?(thismove.pbType(thismove.type,user,nil),PBTypes,:FIRE)
      PBDebug.log("[Lingering effect triggered] #{pbThis}'s Powder cancelled the Fire move")
      @battle.pbCommonAnimation("Powder",user,nil)
      @battle.pbDisplay(_INTL("When the flame touched the powder on the Pokémon, it exploded!"))
      user.pbReduceHP(1+(user.totalhp/4).floor) if !user.hasWorkingAbility(:MAGICGUARD)
      user.effects[PBEffects::StompingTantrum]=true
      user.lastMoveFailed=thismove.id
      user.lastMoveUsed=thismove.id
      user.lastMoveUsedType=thismove.pbType(thismove.type,user,nil)
      if !turneffects[PBEffects::SpecialUsage]
        user.lastMoveUsedSketch=thismove.id if user.effects[PBEffects::TwoTurnAttack]==0
        user.lastRegularMoveUsed=thismove.id
      end
      @battle.lastMoveUsed=thismove.id
      @battle.lastMoveUser=user.index
      if thismove.function==0x170 # Mind Blown
        user.pbReduceHP((user.totalhp/2.0).round) if !user.hasWorkingAbility(:MAGICGUARD)
      end
      user.pbFaint if user.fainted?
      pbEndTurn(choice)
      return
    end
    # Protean

  def pbEffect(attacker,opponent,hitnum=0,alltargets=nil,showanimation=true)
    return 0 if !opponent
    damage=pbCalcDamage(attacker,opponent)
    if opponent.damagestate.typemod!=0
      pbShowAnimation(@id,attacker,opponent,hitnum,alltargets,showanimation)
    end
    damage=pbReduceHPDamage(damage,attacker,opponent)
    if isConst?(thismove.id,PBMoves,:MINDBLOWN)
      if !attacker.hasWorkingAbility(:MAGICGUARD)
        PBDebug.log("[Move effect triggered] #{attacker.pbThis} took damage")
        if attacker.hasWorkingAbility(:PARENTALBOND)
          if attacker.effects[PBEffects::ParentalBond]==2
            attacker.pbReduceHP((attacker.totalhp/2).round)
          end
        else
          attacker.pbReduceHP((attacker.totalhp/2).round)
        end
      end
    end
    pbEffectMessages(attacker,opponent)
    pbOnDamageLost(damage,attacker,opponent)
    return damage   # The HP lost by the opponent due to this attack
  end

################################################################################
# User takes recoil damage equal to 1/2 of the damage this move dealt. (Mind Blown)
################################################################################
class PokeBattle_Move_170 < PokeBattle_Move
  def pbOnStartUse(attacker)
    if !attacker.hasMoldBreaker
      [email protected](:DAMP)
      if bearer!=nil
        @battle.pbDisplay(_INTL("{1}'s {2} prevents {3} from using {4}!",
          bearer.pbThis,PBAbilities.getName(bearer.ability),attacker.pbThis(true),@name))
        return false
      end
    end
    return true
  end
end

    realnumhits=0
    totaldamage=0
    destinybond=false
    currentHP=target.hp
    for i in 0...numhits
      target.damagestate.reset
      # Check success (accuracy/evasion calculation)

      if target.damagestate.calcdamage>0 && !target.fainted?
        # Defrost
        if target.status==PBStatuses::FROZEN &&
           (isConst?(thismove.pbType(thismove.type,user,target),PBTypes,:FIRE) ||
           (USENEWBATTLEMECHANICS && isConst?(thismove.id,PBMoves,:SCALD)))
          target.pbCureStatus
        end
        # Rage
        if target.effects[PBEffects::Rage] && target.pbIsOpposing?(user.index)
          # TODO: Apparently triggers if opposing Pokémon uses Future Sight after a Future Sight attack
          if target.pbIncreaseStatWithCause(PBStats::ATTACK,1,target,"",true,false)
            PBDebug.log("[Lingering effect triggered] #{target.pbThis}'s Rage (raising Attack)")
            @battle.pbDisplay(_INTL("{1}'s rage is building!",target.pbThis))
          end
        end
        # Berserk
        if target.hasWorkingAbility(:BERSERK) && !(user.hasWorkingAbility(:SHEERFORCE) && thismove.addlEffect>0)
          if thismove.pbNumHits(user)==realnumhits && currentHP>=(target.totalhp/2).floor && 
                                                      target.hp<=(target.totalhp/2).floor
            if target.pbIncreaseStatWithCause(PBStats::SPATK,1,target,PBAbilities.getName(target.ability))
              PBDebug.log("[Ability triggered] #{target.pbThis}'s Berserk (raising Special Attack)")
            end
          end
        end
      end
      target.pbFaint if target.fainted? # no return

      # Berry check (maybe just called by ability effect, since only necessary Berries are checked)
      for j in 0...4
        @battle.battlers[j].pbBerryCureCheck(true) if !(@battle.battlers[j].hasWorkingItem(:LEFTOVERS) || 
                                                        @battle.battlers[j].hasWorkingItem(:BLACKSLUDGE))
      end

    pbEffectsAfterHit(user,target,thismove,turneffects)
    # Berry check
    for j in 0...4
      @battle.battlers[j].pbBerryCureCheck(true) if !(@battle.battlers[j].hasWorkingItem(:LEFTOVERS) || 
                                                      @battle.battlers[j].hasWorkingItem(:BLACKSLUDGE))
    end
    target.pbUpdateTargetedMove(thismove,user)

    # Change target to user of Follow Me (overrides Magic Coat
    # because check for Magic Coat below uses this target)
    if PBTargets.targetsOneOpponent?(thismove)
      newtarget=nil; strength=100
      for i in priority # use Pokémon latest in priority
        next if !user.pbIsOpposing?(i.index)
        if !i.fainted? && [email protected] && !target.switching && !i.effects[PBEffects::SkyDrop] &&
           i.effects[PBEffects::FollowMe]>0 && i.effects[PBEffects::FollowMe]<strength
          PBDebug.log("[Lingering effect triggered] #{i.pbThis}'s Follow Me")
          newtarget=i; strength=i.effects[PBEffects::FollowMe]
          changeeffect=0
        end
      end
      target=newtarget if newtarget
    end

    # Pokémon switching caused by U-Turn, Volt Switch, Eject Button
    switched=[]
    for i in 0...4
      pursuit=false
      if @battle.battlers[i].effects[PBEffects::Uturn]
        @battle.battlers[i].switching=true
        @battle.battlers[i].effects[PBEffects::Uturn]=false
        @battle.battlers[i].effects[PBEffects::Roar]=false
        if [email protected][i].fainted? && @battle.pbCanChooseNonActive?(i) &&
           [email protected]?(@battle.pbOpposingParty(i))
          # TODO: Pursuit should go here, and negate this effect if it KO's attacker
          for j in @battle.pbPriority
            next if [email protected][i].pbIsOpposing?(j.index)
            next if pursuit
            [email protected][j.index][1]
            # if Pursuit and this target ("i") was chosen
            if @battle.battlers[j.index].moves[oppmove].function==0x88 && !j.hasMovedThisRound? # Pursuit
             if j.status!=PBStatuses::SLEEP && j.status!=PBStatuses::FROZEN && 
                !j.effects[PBEffects::SkyDrop] && (!j.hasWorkingAbility(:TRUANT) || !j.effects[PBEffects::Truant])
                pursuit=true
                @battle.choices[j.index][3][email protected][i].index # Make sure to target the switching Pokémon
                j.pbUseMove(@battle.choices[j.index]) # This calls pbGainEXP as appropriate
                j.effects[PBEffects::Pursuit]=true
                return if @battle.decision>0
              end
            end
          end
          @battle.battlers[i].switching=false
          break if @battle.battlers[i].fainted?
          @battle.pbDisplay(_INTL("{1} went back to {2}!",@battle.battlers[i].pbThis,@battle.pbGetOwner(i).name))
          newpoke=0
          [email protected](i,true,false)
          newpokename=newpoke
          if isConst?(@battle.pbParty(i)[newpoke].ability,PBAbilities,:ILLUSION)
            newpokename=pbGetLastPokeInTeam(i)
          end
          switched.push(i)
          @battle.battlers[i].pbResetForm
          @battle.pbRecallAndReplace(i,newpoke,newpokename,@battle.battlers[i].effects[PBEffects::BatonPass])
          @battle.choices[i]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
        end
      end
    end
    for i in @battle.pbPriority
      next if !switched.include?(i.index)
      i.pbAbilitiesOnSwitchIn(true)
    end
    # Baton Pass

################################################################################
# Power is doubled if a foe tries to switch out or use U-turn/Volt Switch/
# Parting Shot. (Pursuit)
# (Handled in Battle's pbAttackPhase): Makes this attack happen before switching.
################################################################################
class PokeBattle_Move_088 < PokeBattle_Move
  def pbBaseDamage(basedmg,attacker,opponent)
    if @battle.switching || opponent.switching
      PBDebug.log("[Move Effect] #{attacker.pbThis} double Pursuit damage")
      return basedmg*2
    end
    return basedmg
  end

  def pbAccuracyCheck(attacker,opponent)
    return true if @battle.switching || opponent.switching
    return super(attacker,opponent)
  end
end

      # Shell Bell
      if user.hasWorkingItem(:SHELLBELL) && user.effects[PBEffects::HealBlock]==0
        PBDebug.log("[Item triggered] #{user.pbThis}'s Shell Bell (total damage=#{turneffects[PBEffects::TotalDamage]})")
        previoushp=user.hp
        hpgain=user.pbRecoverHP((turneffects[PBEffects::TotalDamage]/8).floor,true)
        if hpgain>0
          @battle.pbDisplay(_INTL("{1} restored a little HP using its {2}!",user.pbThis,PBItems.getName(user.item)))
        end
        # Wimp Out/ Emergency Exit
        if (user.hasWorkingAbility(:WIMPOUT) || user.hasWorkingAbility(:EMERGENCYEXIT)) && !user.fainted?
          if hpgain>0 && (previoushp<=(user.totalhp/2).floor && user.hp>(user.totalhp/2).floor)
            if [email protected]
              pbSEPlay("Battle flee")
              @battle.pbDisplay(_INTL("{1} fled!",user.pbThis))
              for i in 0...4; @battle.choices[@battle.battlers[i].index][0]=-1; end
              @battle.decision=3
              PBDebug.log("[Escape] #{user.pbThis} fled")
            else
              if @battle.pbCanSwitch?(user.index,-1,false) && @battle.pbCanChooseNonActive?(user.index)
                newpoke=0
                [email protected](user.index,true,false)
                newpokename=newpoke
                if isConst?(@battle.pbParty(user.index)[newpoke].ability,PBAbilities,:ILLUSION)
                  newpokename=pbGetLastPokeInTeam(user.index)
                end
                user.pbResetForm
                @battle.pbRecallAndReplace(user.index,newpoke,newpokename) #,@battle.battlers[i].effects[PBEffects::BatonPass])
                @battle.choices[user.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
                user.pbAbilitiesOnSwitchIn(true)
              end
            end
          end
        end
      end
      # Life Orb

  def pbEffectsAfterHit(user,target,thismove,turneffects)
    return if turneffects[PBEffects::TotalDamage]==0
    if !(user.hasWorkingAbility(:SHEERFORCE) && thismove.addlEffect>0)
      # Target's held items:
      # Red Card
      if target.hasWorkingItem(:REDCARD) && @battle.pbCanSwitch?(user.index,-1,false) &&
         !user.fainted? && @battle.pbCanChooseNonActive?(user.index)
        @battle.pbDisplay(_INTL("{1} held up its {2} against the {3}!",target.pbThis,PBItems.getName(target.item),user.pbThis(true)))
        target.pbConsumeItem
        choices=[]
        [email protected](user.index)
        for j in 0...party.length
          choices.push(j) if @battle.pbCanSwitchLax?(user.index,j,false)
        end
        if choices.length>0
          newpoke=choices[@battle.pbRandom(choices.length)]
          newpokename=newpoke
          if isConst?(party[newpoke].ability,PBAbilities,:ILLUSION)
            newpokename=pbGetLastPokeInTeam(user.index)
          end
          user.pbResetForm
          @battle.pbRecallAndReplace(user.index,newpoke,newpokename,false,
                                      user.hasMoldBreaker || thismove.ignoresAbilities?)
          @battle.pbDisplay(_INTL("{1} was dragged out!",user.pbThis))
          @battle.choices[user.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
          user.pbAbilitiesOnSwitchIn(true)
        end
      # Eject Button
      elsif target.hasWorkingItem(:EJECTBUTTON) && @battle.pbCanChooseNonActive?(target.index)
        @battle.pbDisplay(_INTL("{1} is switched out with the {2}!",target.pbThis,PBItems.getName(target.item)))
        target.pbConsumeItem(false,true)
        newpoke=0
        [email protected](target.index,true,false)
        newpokename=newpoke
        if isConst?(@battle.pbParty(target.index)[newpoke].ability,PBAbilities,:ILLUSION)
          newpokename=pbGetLastPokeInTeam(i)
        end
        @battle.battlers[target.index].pbResetForm
        @battle.pbRecallAndReplace(target.index,newpoke,newpokename,@battle.battlers[i].effects[PBEffects::BatonPass])
        @battle.choices[target.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
        target.pbAbilitiesOnSwitchIn(true)
      end
      # User's held items:
      # Shell Bell

      # Wimp Out/ Emergency Exit
      if (target.hasWorkingAbility(:WIMPOUT) || target.hasWorkingAbility(:EMERGENCYEXIT)) &&
         !target.effects[PBEffects::SkyDrop] && thismove.function!=0x0EC # Circle Throw, Dragon Tail
        if target.hp+turneffects[PBEffects::TotalDamage]>(target.totalhp/2).floor && 
           target.hp<=(target.totalhp/2).floor
          PBDebug.log("[Ability triggered] #{target.pbThis}'s #{PBAbilities.getName(target.ability)}")
          if [email protected]
            pbSEPlay("Battle flee"); @battle.pbDisplay(_INTL("{1} fled!",target.pbThis))
            for i in 0...4
              @battle.choices[@battle.battlers[i].index][0]=-1
            end
            @battle.decision=3
            PBDebug.log("[Escape] #{target.pbThis} fled")
          else
            if @battle.pbCanSwitch?(target.index,-1,false) &&@battle.pbCanChooseNonActive?(target.index)
              newpoke=0
              [email protected](target.index,true,false)
              newpokename=newpoke
              if isConst?(@battle.pbParty(target.index)[newpoke].ability,PBAbilities,:ILLUSION)
                newpokename=pbGetLastPokeInTeam(target.index)
              end
              target.pbResetForm
              @battle.pbRecallAndReplace(target.index,newpoke,newpokename)
              @battle.choices[target.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
              target.pbAbilitiesOnSwitchIn(true)
            end
          end
        end
      end
    end
    # Moxie

      # Spikes
      if pkmn.pbOwnSide.effects[PBEffects::Spikes]>0 && !pkmn.isAirborne?(moldbreaker)
        if !pkmn.hasWorkingAbility(:MAGICGUARD)
          PBDebug.log("[Entry hazard] #{pkmn.pbThis} triggered Spikes")
          spikesdiv=[8,6,4][pkmn.pbOwnSide.effects[PBEffects::Spikes]-1]          
          @scene.pbDamageAnimation(pkmn,0)
          currentHP=pkmn.hp
          pkmn.pbReduceHP((pkmn.totalhp/spikesdiv).floor)
          pbDisplayPaused(_INTL("{1} is hurt by the spikes!",pkmn.pbThis))
          if (pkmn.hasWorkingAbility(:WIMPOUT) || pkmn.hasWorkingAbility(:EMERGENCYEXIT)) && !pkmn.fainted?
            pkmn.pbBerryCureCheck(true)
            if currentHP>=(pkmn.totalhp/2).floor && pkmn.hp<=(pkmn.totalhp/2).floor
              PBDebug.log("[Ability triggered] #{pkmn.pbThis}'s #{PBAbilities.getName(pkmn.ability)}")
              if [email protected]
                pbSEPlay("Battle flee"); @battle.pbDisplay(_INTL("{1} fled!",pkmn.pbThis))
                for i in 0...4; @battle.choices[@battle.battlers[i].index][0]=-1; end
                @decision=3
                PBDebug.log("[Escape] #{pkmn.pbThis} fled")
              else
                if pbCanSwitch?(pkmn.index,-1,false) && @battle.pbCanChooseNonActive?(pkmn.index)
                  newpoke=0
                  newpoke=pbSwitchInBetween(pkmn.index,true,false)
                  newpokename=newpoke
                  if isConst?(pbParty(pkmn.index)[newpoke].ability,PBAbilities,:ILLUSION)
                    newpokename=pbGetLastPokeInTeam(pkmn.index)
                  end
                  pkmn.pbResetForm
                  pbRecallAndReplace(pkmn.index,newpoke,newpokename)
                  @choices[pkmn.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
                  pkmn.pbAbilitiesOnSwitchIn(true)
                end
              end
            end
          end
        end
      end
      pkmn.pbFaint if pkmn.fainted?
      # Stealth Rock
      if pkmn.pbOwnSide.effects[PBEffects::StealthRock] && !pkmn.fainted?
        if !pkmn.hasWorkingAbility(:MAGICGUARD)
          atype=getConst(PBTypes,:ROCK) || 0
          eff=PBTypes.getCombinedEffectiveness(atype,pkmn.type1,pkmn.type2,pkmn.effects[PBEffects::Type3])
          if eff>0
            PBDebug.log("[Entry hazard] #{pkmn.pbThis} triggered Stealth Rock")
            @scene.pbDamageAnimation(pkmn,0)
            currentHP=pkmn.hp
            pkmn.pbReduceHP(((pkmn.totalhp*eff)/64).floor)
            pbDisplayPaused(_INTL("Pointed stones dug into {1}!",pkmn.pbThis))
            if (pkmn.hasWorkingAbility(:WIMPOUT) || pkmn.hasWorkingAbility(:EMERGENCYEXIT)) && !pkmn.fainted?
              pkmn.pbBerryCureCheck(true)
              if currentHP>=(pkmn.totalhp/2).floor && pkmn.hp<=(pkmn.totalhp/2).floor
                PBDebug.log("[Ability triggered] #{pkmn.pbThis}'s #{PBAbilities.getName(pkmn.ability)}")
                if [email protected]
                  pbSEPlay("Battle flee"); @battle.pbDisplay(_INTL("{1} fled!",pkmn.pbThis))
                  for i in 0...4; @battle.choices[@battle.battlers[i].index][0]=-1; end
                  @decision=3
                  PBDebug.log("[Escape] #{pkmn.pbThis} fled")
                else
                  if pbCanSwitch?(pkmn.index,-1,false) && @battle.pbCanChooseNonActive?(pkmn.index)
                    newpoke=0
                    newpoke=pbSwitchInBetween(pkmn.index,true,false)
                    newpokename=newpoke
                    if isConst?(pbParty(pkmn.index)[newpoke].ability,PBAbilities,:ILLUSION)
                      newpokename=pbGetLastPokeInTeam(pkmn.index)
                    end
                    pkmn.pbResetForm
                    pbRecallAndReplace(pkmn.index,newpoke,newpokename)
                    @choices[pkmn.index]=[0,0,nil,-1]   # Replacement Pokémon does nothing this round
                    pkmn.pbAbilitiesOnSwitchIn(true)
                  end
                end
              end
            end
          end
        end
      end
      pkmn.pbFaint if pkmn.fainted?
      # Toxic Spikes

################################################################################
# After inflicting damage, user switches out. Ignores trapping moves.
# (U-turn, Volt Switch)
# TODO: Pursuit should interrupt this move.
################################################################################
class PokeBattle_Move_0EE < PokeBattle_Move
  def pbEffectAfterHit(attacker,opponent,turneffects)
    if !attacker.fainted? && opponent.damagestate.calcdamage>0 && 
       @battle.pbCanChooseNonActive?(attacker.index) && [email protected]?(@battle.pbParty(opponent.index))
      if (opponent.hasWorkingAbility(:WIMPOUT) || opponent.hasWorkingAbility(:EMERGENCYEXIT)) && 
          opponent.hp+turneffects[PBEffects::TotalDamage]>(opponent.totalhp/2).floor &&
          opponent.hp<=(opponent.totalhp/2).floor
        attacker.effects[PBEffects::Uturn]=false
      else
        attacker.effects[PBEffects::Uturn]=true
      end
    end
  end
end

################################################################################
# Always hits. (Hyperspace Hole)
################################################################################
class PokeBattle_Move_147 < PokeBattle_Move
  def pbAccuracyCheck(attacker,opponent)
    return true
  end
  
  def pbEffectAfterHit(attacker,opponent,turneffects)
    if !opponent.fainted? && opponent.damagestate.calcdamage>0
      opponent.effects[PBEffects::Protect]=false
      opponent.effects[PBEffects::KingsShield]=false
      opponent.effects[PBEffects::SpikyShield]=false
      opponent.effects[PBEffects::BanefulBunker]=false
      opponent.pbOwnSide.effects[PBEffects::QuickGuard]=false
      opponent.pbOwnSide.effects[PBEffects::WideGuard]=false
      opponent.pbOwnSide.effects[PBEffects::CraftyShield]=false
      opponent.pbOwnSide.effects[PBEffects::MatBlock]=false
    end
  end
end