Battle Shadows

class Sprite

  def skew(angle=90)
    return false if !self.bitmap
    angle=angle*(Math::PI/180)
    bitmap=self.bitmap
    rect=Rect.new(0,0,bitmap.width,bitmap.height)
    width=rect.width+((rect.height-1)/Math.tan(angle))
    self.bitmap=Bitmap.new(width,rect.height)
    for i in 0...rect.height
      y=rect.height-i
      x=i/Math.tan(angle)
      self.bitmap.blt(x+rect.x,y+rect.y,bitmap,Rect.new(0,y,rect.width,1))
    end
  end


end



class PokemonBattlerSprite
    #techshadow
  attr_accessor :shadow
  attr_accessor :showshadow



  def initialize(viewport,sideSize,index,battleAnimations)
    super(viewport)
    @pkmn             = nil
    @sideSize         = sideSize
    @index            = index
    @battleAnimations = battleAnimations
    # @selected: 0 = not selected, 1 = choosing action bobbing for this Pokémon,
    #            2 = flashing when targeted
    @selected         = 0
    @frame            = 0
    @updating         = false
    @spriteX          = 0   # Actual x coordinate
    @spriteY          = 0   # Actual y coordinate
    @spriteXExtra     = 0   # Offset due to "bobbing" animation
    @spriteYExtra     = 0   # Offset due to "bobbing" animation
    @_iconBitmap      = nil
    self.visible      = false
    #techshadow
    @shadow           = Sprite.new(viewport)
    @showshadow       = true
  end



  def dispose
    @_iconBitmap.dispose if @_iconBitmap
    #techshadow
    @shadow.dispose if @shadow
    @_iconBitmap = nil
    self.bitmap = nil if !self.disposed?
    super
  end

  def x=(value)
    @spriteX = value
    #techshadow
    @shadow.x=value
    self.formatShadow
    super(value+@spriteXExtra)
  end

  def y=(value)
    @spriteY = value
    #techshadow
    @shadow.y=value
    self.formatShadow
    super(value+@spriteYExtra)
  end


  def setPokemonBitmap(pkmn,back=false)
    @pkmn = pkmn
    @_iconBitmap.dispose if @_iconBitmap
    @_iconBitmap = pbLoadPokemonBitmap(@pkmn,back)
    #techshadow
    @shadow.bitmap    = @_iconBitmap.bitmap.clone
    self.formatShadow
    self.bitmap = (@_iconBitmap) ? @_iconBitmap.bitmap : nil
    pbSetPosition
  end


  def update(frameCounter=0)
    return if !@_iconBitmap
    @updating = true
    # Update bitmap
    @_iconBitmap.update
    @shadow.bitmap    = @_iconBitmap.bitmap.clone
    @shadow.update
    self.bitmap = @_iconBitmap.bitmap
    # Pokémon sprite bobbing while Pokémon is selected
    @spriteYExtra = 0
    if @selected==1    # When choosing commands for this Pokémon
      case (frameCounter/QUARTER_ANIM_PERIOD).floor
      when 1; @spriteYExtra = 2
      when 3; @spriteYExtra = -2
      end
    end
    self.x       = self.x
    self.y       = self.y
    self.visible = @spriteVisible
    # Pokémon sprite blinking when targeted
    if @selected==2 && @spriteVisible
      case (frameCounter/SIXTH_ANIM_PERIOD).floor
      when 2, 5; self.visible = false
      else;      self.visible = true
      end
    end
    @updating = false
  end


  def formatShadow
   @shadow.zoom_x =  self.zoom_x*0.90
    @shadow.zoom_y =  self.zoom_y*0.30
    @shadow.z =  self.z-1
    @shadow.ox = self.ox - 6
    @shadow.oy = self.oy #- 20
    @shadow.opacity =  self.opacity*0.3
    @shadow.tone = Tone.new(-255,-255,-255,255)
    @shadow.visible =  self.visible
    @shadow.mirror =  self.mirror
    @shadow.angle =  self.angle
    @shadow.visible = false if !@showshadow
  end


end



class PokeballPlayerSendOutAnimation < PokeBattle_Animation
  include PokeBattle_BallAnimationMixin

  def initialize(sprites,viewport,idxTrainer,battler,startBattle,idxOrder=0)
    @idxTrainer     = idxTrainer
    @battler        = battler
    @showingTrainer = startBattle
    @idxOrder       = idxOrder
    @trainer        = @battler.battle.pbGetOwnerFromBattlerIndex(@battler.index)
    sprites["pokemon_#{battler.index}"].visible = false
    super(sprites,viewport)
  end

  def createProcesses
    batSprite = @sprites["pokemon_#{@battler.index}"]
    traSprite = @sprites["player_#{@idxTrainer}"]
    # Calculate the Poké Ball graphic to use
    ballType = 0
    if !batSprite.pkmn.nil?
      ballType = batSprite.pkmn.ballused || 0
    end
    # Calculate the color to turn the battler sprite
    col = getBattlerColorFromBallType(ballType)
    col.alpha = 255
    # Calculate start and end coordinates for battler sprite movement
    ballPos = PokeBattle_SceneConstants.pbBattlerPosition(@battler.index,batSprite.sideSize)
    battlerStartX = ballPos[0]   # Is also where the Ball needs to end
    battlerStartY = ballPos[1]   # Is also where the Ball needs to end + 18
    battlerEndX = batSprite.x
    battlerEndY = batSprite.y
    # Calculate start and end coordinates for Poké Ball sprite movement
    ballStartX = -6
    ballStartY = 202
    ballMidX = 0   # Unused in trajectory calculation
    ballMidY = battlerStartY-144
    # Set up Poké Ball sprite
    ball = addBallSprite(ballStartX,ballStartY,ballType)
    ball.setZ(0,25)
    ball.setVisible(0,false)
    # Poké Ball tracking the player's hand animation (if trainer is visible)
    if @showingTrainer && traSprite && traSprite.x>0
      ball.setZ(0,traSprite.z-1)
      ballStartX, ballStartY = ballTracksHand(ball,traSprite)
    end
    delay = ball.totalDuration   # 0 or 7
    # Poké Ball trajectory animation
    createBallTrajectory(ball,delay,12,
       ballStartX,ballStartY,ballMidX,ballMidY,battlerStartX,battlerStartY-18)
    ball.setZ(9,batSprite.z-1)
    delay = ball.totalDuration+4
    delay += 10*@idxOrder   # Stagger appearances if multiple Pokémon are sent out at once
    ballOpenUp(ball,delay-2,ballType)
    ballBurst(delay,battlerStartX,battlerStartY-18,ballType)
    ball.moveOpacity(delay+2,2,0)
    # Set up battler sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    battler.setXY(0,battlerStartX,battlerStartY)
    battler.setZoom(0,0)
    battler.setColor(0,col)
    # Battler animation
    battlerAppear(battler,delay,battlerEndX,battlerEndY,batSprite,col)
    #if @shadowVisible
      # Set up shadow sprite
      batSprite.showshadow = true
      batSprite.formatShadow
      #shadow.setOpacity(0,0)
     # Shadow animation
      #shadow.setVisible(delay,@shadowVisible)
      #shadow.moveOpacity(delay+5,10,255)
   # end
  end
end


class PokeballTrainerSendOutAnimation < PokeBattle_Animation
  include PokeBattle_BallAnimationMixin

  def initialize(sprites,viewport,idxTrainer,battler,startBattle,idxOrder)
    @idxTrainer     = idxTrainer
    @battler        = battler
    @showingTrainer = startBattle
    @idxOrder       = idxOrder
    sprites["pokemon_#{battler.index}"].visible = false
    @shadowVisible = sprites["pokemon_#{battler.index}"].showshadow
    sprites["pokemon_#{battler.index}"].showshadow = false
    super(sprites,viewport)
  end

  def createProcesses
    batSprite = @sprites["pokemon_#{@battler.index}"]
    shaSprite = @sprites["pokemon_#{@battler.index}"].shadow
    # Calculate the Poké Ball graphic to use
    ballType = 0
    if !batSprite.pkmn.nil?
      ballType = batSprite.pkmn.ballused || 0
    end
    # Calculate the color to turn the battler sprite
    col = getBattlerColorFromBallType(ballType)
    col.alpha = 255
    # Calculate start and end coordinates for battler sprite movement
    ballPos = PokeBattle_SceneConstants.pbBattlerPosition(@battler.index,batSprite.sideSize)
    battlerStartX = ballPos[0]
    battlerStartY = ballPos[1]
    battlerEndX = batSprite.x
    battlerEndY = batSprite.y
    # Set up Poké Ball sprite
    ball = addBallSprite(0,0,ballType)
    ball.setZ(0,batSprite.z-1)
    # Poké Ball animation
    createBallTrajectory(ball,battlerStartX,battlerStartY)
    delay = ball.totalDuration+6
    delay += 10 if @showingTrainer   # Give time for trainer to slide off screen
    delay += 10*@idxOrder   # Stagger appearances if multiple Pokémon are sent out at once
    ballOpenUp(ball,delay-2,ballType)
    ballBurst(delay,battlerStartX,battlerStartY-18,ballType)
    ball.moveOpacity(delay+2,2,0)
    # Set up battler sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    battler.setXY(0,battlerStartX,battlerStartY)
    battler.setZoom(0,0)
    battler.setColor(0,col)
    # Battler animation
    battlerAppear(battler,delay,battlerEndX,battlerEndY,batSprite,col)
   # if @shadowVisible
      # Set up shadow sprite
      battler.showsprite = true
      battler.formatShadow
     # shadow.setOpacity(0,0)
     # Shadow animation
     # shadow.setVisible(delay,@shadowVisible)
     # shadow.moveOpacity(delay+5,10,255)
  #  end
  end

  def createBallTrajectory(ball,destX,destY)
    # NOTE: In HGSS, there isn't a Poké Ball arc under any circumstance (neither
    #       when throwing out the first Pokémon nor when switching/replacing a
    #       fainted Pokémon). This is probably worth changing.
    ball.setXY(0,destX,destY-4)
  end
end



#===============================================================================
# Shows a Pokémon being recalled into its Poké Ball
#===============================================================================
class BattlerRecallAnimation < PokeBattle_Animation
  include PokeBattle_BallAnimationMixin

  def initialize(sprites,viewport,idxBattler)
    @idxBattler = idxBattler
    super(sprites,viewport)
  end

  def createProcesses
    batSprite = @sprites["pokemon_#{@idxBattler}"]
    shaSprite = @sprites["pokemon_#{@idxBattler}"].shadow
    # Calculate the Poké Ball graphic to use
    ballType = 0
    if !batSprite.pkmn.nil?
      ballType = batSprite.pkmn.ballused || 0
    end
    # Calculate the color to turn the battler sprite
    col = getBattlerColorFromBallType(ballType)
    col.alpha = 0
    # Calculate end coordinates for battler sprite movement
    ballPos = PokeBattle_SceneConstants.pbBattlerPosition(@idxBattler,batSprite.sideSize)
    battlerEndX = ballPos[0]
    battlerEndY = ballPos[1]
    # Set up battler sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    battler.setVisible(0,true)
    battler.setColor(0,col)
    # Set up Poké Ball sprite
    ball = addBallSprite(battlerEndX,battlerEndY,ballType)
    ball.setZ(0,batSprite.z+1)
    # Poké Ball animation
    ballOpenUp(ball,0,ballType)
    delay = ball.totalDuration
    ballBurstRecall(delay,battlerEndX,battlerEndY,ballType)
    ball.moveOpacity(10,2,0)
    # Battler animation
    battlerAbsorb(battler,delay,battlerEndX,battlerEndY,col)
    if batSprite.showshadow
      # Set up shadow sprite
      batSprite.formatShadow
      # Shadow animation
     # shadow.moveOpacity(0,10,0)
    #  shadow.setVisible(delay,false)
   end
  end
end


#===============================================================================
# Shows a Pokémon flashing after taking damage
#===============================================================================
class BattlerDamageAnimation < PokeBattle_Animation
  def initialize(sprites,viewport,idxBattler,effectiveness)
    @idxBattler    = idxBattler
    @effectiveness = effectiveness
    super(sprites,viewport)
  end

  def createProcesses
    batSprite = @sprites["pokemon_#{@idxBattler}"]
    # Set up battler/shadow sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    # Animation
    delay = 0
    case @effectiveness
    when 0; battler.setSE(delay,"Battle damage normal")
    when 1; battler.setSE(delay,"Battle damage weak")
    when 2; battler.setSE(delay,"Battle damage super")
    end
    4.times do   # 4 flashes, each lasting 0.2 (4/20) seconds
      battler.setVisible(delay,false)
      battler.setVisible(delay+2,true) if batSprite.visible
      delay += 4
    end
    # Restore original battler/shadow sprites visibilities
    battler.setVisible(delay,batSprite.visible)
  end
end



#===============================================================================
# Shows a Pokémon fainting
#===============================================================================
class BattlerFaintAnimation < PokeBattle_Animation
  def initialize(sprites,viewport,idxBattler,battle)
    @idxBattler = idxBattler
    @battle     = battle
    super(sprites,viewport)
  end

  def createProcesses
    batSprite = @sprites["pokemon_#{@idxBattler}"]
    shaSprite = @sprites["pokemon_#{@idxBattler}"].shadow
    # Set up battler/shadow sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    batSprite.formatShadow
    # Get approx duration depending on sprite's position/size. Min 20 frames.
    battlerTop = batSprite.y-batSprite.height
    cropY = PokeBattle_SceneConstants.pbBattlerPosition(@idxBattler,
       @battle.pbSideSize(@idxBattler))[1]
    cropY += 8
    duration = (cropY-battlerTop)/8
    duration = 10 if duration<10   # Min 0.5 seconds
    # Animation
    # Play cry
    delay = 10
    cry = pbCryFile(batSprite.pkmn)
    if cry
      battler.setSE(0,pbCryFile(batSprite.pkmn),nil,75)   # 75 is pitch
      delay = pbCryFrameLength(batSprite.pkmn)*20/Graphics.frame_rate
    end
    # Sprite drops down
   # shaSprite.setVisible(delay,false)
    battler.setSE(delay,"Pkmn faint")
    battler.moveOpacity(delay,duration,0)
    battler.moveDelta(delay,duration,0,cropY-battlerTop)
    battler.setCropBottom(delay,cropY)
    battler.setVisible(delay+duration,false)
    battler.setOpacity(delay+duration,255)
  end
end



#===============================================================================
# Shows the player's Poké Ball being thrown to capture a Pokémon
#===============================================================================
class PokeballThrowCaptureAnimation < PokeBattle_Animation
  include PokeBattle_BallAnimationMixin

  def initialize(sprites,viewport,
                 ballType,numShakes,critCapture,battler,showingTrainer)
    @ballType       = ballType
    @numShakes      = (critCapture) ? 1 : numShakes
    @critCapture    = critCapture
    @battler        = battler
    @showingTrainer = showingTrainer    # Only true if a Safari Zone battle
    @shadowVisible  = sprites["pokemon_#{battler.index}"].showshadow
    @trainer        = battler.battle.pbPlayer
    super(sprites,viewport)
  end

  def createProcesses
    # Calculate start and end coordinates for battler sprite movement
    batSprite = @sprites["pokemon_#{@battler.index}"]
    traSprite = @sprites["player_1"]
    ballPos = PokeBattle_SceneConstants.pbBattlerPosition(@battler.index,batSprite.sideSize)
    battlerStartX = batSprite.x
    battlerStartY = batSprite.y
    ballStartX = -6
    ballStartY = 246
    ballMidX   = 0   # Unused in arc calculation
    ballMidY   = 78
    ballEndX   = ballPos[0]
    ballEndY   = 112
    ballGroundY = ballPos[1]-4
    # Set up Poké Ball sprite
    ball = addBallSprite(ballStartX,ballStartY,@ballType)
    ball.setZ(0,batSprite.z+1)
    @ballSpriteIndex = (@numShakes>=4 || @critCapture) ? @tempSprites.length-1 : -1
    # Set up trainer sprite (only visible in Safari Zone battles)
    if @showingTrainer && traSprite
      if traSprite.bitmap.width>=traSprite.bitmap.height*2
        trainer = addSprite(traSprite,PictureOrigin::Bottom)
        # Trainer animation
        ballStartX, ballStartY = trainerThrowingFrames(ball,trainer,traSprite)
      end
    end
    delay = ball.totalDuration   # 0 or 7
    # Poké Ball arc animation
    ball.setSE(delay,"Battle throw")
    createBallTrajectory(ball,delay,16,
       ballStartX,ballStartY,ballMidX,ballMidY,ballEndX,ballEndY)
    ball.setZ(9,batSprite.z+1)
    ball.setSE(delay+16,"Battle ball hit")
    # Poké Ball opens up
    delay = ball.totalDuration+6
    ballOpenUp(ball,delay,@ballType,true,false)
    # Set up battler sprite
    battler = addSprite(batSprite,PictureOrigin::Bottom)
    # Poké Ball absorbs battler
    delay = ball.totalDuration
    ballBurstCapture(delay,ballEndX,ballEndY,@ballType)
    delay = ball.totalDuration+4
    # NOTE: The Pokémon does not change color while being absorbed into a Poké
    #       Ball during a capture attempt. This may be an oversight in HGSS.
    battler.setSE(delay,"Battle jump to ball")
    battler.moveXY(delay,5,ballEndX,ballEndY)
    battler.moveZoom(delay,5,0)
    battler.setVisible(delay+5,false)
   # if @shadowVisible
      # Set up shadow sprite
   #   shadow = addSprite(shaSprite,PictureOrigin::Center)
      # Shadow animation
   #   shadow.moveOpacity(delay,5,0)
   #   shadow.moveZoom(delay,5,0)
   #   shadow.setVisible(delay+5,false)
   # end
    # Poké Ball closes
    delay = battler.totalDuration
    ballSetClosed(ball,delay,@ballType)
    ball.moveTone(delay,3,Tone.new(96,64,-160,160))
    ball.moveTone(delay+5,3,Tone.new(0,0,0,0))
    # Poké Ball critical capture animation
    delay = ball.totalDuration+3
    if @critCapture
      ball.setSE(delay,"Battle ball shake")
      ball.moveXY(delay,1,ballEndX+4,ballEndY)
      ball.moveXY(delay+1,2,ballEndX-4,ballEndY)
      ball.moveXY(delay+3,2,ballEndX+4,ballEndY)
      ball.setSE(delay+4,"Battle ball shake")
      ball.moveXY(delay+5,2,ballEndX-4,ballEndY)
      ball.moveXY(delay+7,1,ballEndX,ballEndY)
      delay = ball.totalDuration+3
    end
    # Poké Ball drops to the ground
    for i in 0...4
      t = [4,4,3,2][i]   # Time taken to rise or fall for each bounce
      d = [1,2,4,8][i]   # Fraction of the starting height each bounce rises to
      delay -= t if i==0
      if i>0
        ball.setZoomXY(delay,100+5*(5-i),100-5*(5-i))   # Squish
        ball.moveZoom(delay,2,100)                      # Unsquish
        ball.moveXY(delay,t,ballEndX,ballGroundY-(ballGroundY-ballEndY)/d)
      end
      ball.moveXY(delay+t,t,ballEndX,ballGroundY)
      ball.setSE(delay+2*t,"Battle ball drop",100-i*7)
      delay = ball.totalDuration
    end
    battler.setXY(ball.totalDuration,ballEndX,ballGroundY)
    # Poké Ball shakes
    delay = ball.totalDuration+12
    for i in 0...[@numShakes,3].min
      ball.setSE(delay,"Battle ball shake")
      ball.moveXY(delay,2,ballEndX-2*(4-i),ballGroundY)
      ball.moveAngle(delay,2,5*(4-i))   # positive means counterclockwise
      ball.moveXY(delay+2,4,ballEndX+2*(4-i),ballGroundY)
      ball.moveAngle(delay+2,4,-5*(4-i))   # negative means clockwise
      ball.moveXY(delay+6,2,ballEndX,ballGroundY)
      ball.moveAngle(delay+6,2,0)
      delay = ball.totalDuration+8
    end
    if @numShakes==0 || (@numShakes<4 && !@critCapture)
      # Poké Ball opens
      ball.setZ(delay,batSprite.z-1)
      ballOpenUp(ball,delay,@ballType,false)
      ballBurst(delay,ballEndX,ballGroundY,@ballType)
      ball.moveOpacity(delay+2,2,0)
      # Battler emerges
      col = getBattlerColorFromBallType(@ballType)
      col.alpha = 255
      battler.setColor(delay,col)
      battlerAppear(battler,delay,battlerStartX,battlerStartY,batSprite,col)
     # if @shadowVisible
    #    shadow.setVisible(delay+5,true)
     #   shadow.setZoom(delay+5,100)
    #    shadow.moveOpacity(delay+5,10,255)
    #  end
    else
      # Pokémon was caught
      ballCaptureSuccess(ball,delay,ballEndX,ballGroundY)
    end
  end

  def dispose
    if @ballSpriteIndex>=0
      # Capture was successful, the Poké Ball sprite should stay around after
      # this animation has finished.
      @sprites["captureBall"] = @tempSprites[@ballSpriteIndex]
      @tempSprites[@ballSpriteIndex] = nil
    end
    super
  end
end



class BattleIntroAnimation < PokeBattle_Animation

  def createProcesses
    appearTime = 20   # This is in 1/20 seconds
    # Background
    if @sprites["battle_bg2"]
      makeSlideSprite("battle_bg",0.5,appearTime)
      makeSlideSprite("battle_bg2",0.5,appearTime)
    end
    # Bases
    makeSlideSprite("base_0",1,appearTime,PictureOrigin::Bottom)
    makeSlideSprite("base_1",-1,appearTime,PictureOrigin::Center)
    # Player sprite, partner trainer sprite
    @battle.player.each_with_index do |_p,i|
      makeSlideSprite("player_#{i+1}",1,appearTime,PictureOrigin::Bottom)
    end
    # Opposing trainer sprite(s) or wild Pokémon sprite(s)
    if @battle.trainerBattle?
      @battle.opponent.each_with_index do |_p,i|
        makeSlideSprite("trainer_#{i+1}",-1,appearTime,PictureOrigin::Bottom)
      end
    else   # Wild battle
      @battle.pbParty(1).each_with_index do |_pkmn,i|
        idxBattler = 2*i+1
        makeSlideSprite("pokemon_#{idxBattler}",-1,appearTime,PictureOrigin::Bottom)
      end
    end
    # Fading blackness over whole screen
    blackScreen = addNewSprite(0,0,"Graphics/Battle animations/black_screen")
    blackScreen.setZ(0,999)
    blackScreen.moveOpacity(0,8,0)
    # Fading blackness over command bar
    blackBar = addNewSprite(@sprites["cmdBar_bg"].x,@sprites["cmdBar_bg"].y,
       "Graphics/Battle animations/black_bar")
    blackBar.setZ(0,998)
    blackBar.moveOpacity(appearTime*3/4,appearTime/4,0)
  end

end




class PokeBattle_Scene
  def pbFrameUpdate(cw=nil)
    cw.update if cw
    @battle.battlers.each_with_index do |b,i|
      next if !b
      @sprites["dataBox_#{i}"].update(@frameCounter) if @sprites["dataBox_#{i}"]
      @sprites["pokemon_#{i}"].update(@frameCounter) if @sprites["pokemon_#{i}"]
    end
  end


  # Used by Ally Switch.
  def pbSwapBattlerSprites(idxA,idxB)
    @sprites["pokemon_#{idxA}"], @sprites["pokemon_#{idxB}"] = @sprites["pokemon_#{idxB}"], @sprites["pokemon_#{idxA}"]
    @lastCmd[idxA], @lastCmd[idxB] = @lastCmd[idxB], @lastCmd[idxA]
    @lastMove[idxA], @lastMove[idxB] = @lastMove[idxB], @lastMove[idxA]
    [idxA,idxB].each do |i|
      @sprites["pokemon_#{i}"].index = i
      @sprites["pokemon_#{i}"].pbSetPosition
      @sprites["shadow_#{i}"].pbSetPosition
      @sprites["dataBox_#{i}"].battler = @battle.battlers[i]
    end
    pbRefresh
  end


  def pbChangePokemon(idxBattler,pkmn)
    idxBattler = idxBattler.index if idxBattler.respond_to?("index")
    pkmnSprite   = @sprites["pokemon_#{idxBattler}"]
    back = !@battle.opposes?(idxBattler)
    pkmnSprite.setPokemonBitmap(pkmn,back)
    pkmnSprite.formatShadow
    # Set visibility of battler's shadow
    if !back
      pkmnSprite.showshadow = showShadow?(pkmn.fSpecies)
    end
  end


  def pbCreatePokemonSprite(idxBattler)
    sideSize = @battle.pbSideSize(idxBattler)
    batSprite = PokemonBattlerSprite.new(@viewport,sideSize,idxBattler,@animations)
    batSprite.showshadow = false
    @sprites["pokemon_#{idxBattler}"] = batSprite
  end

end