#--------------------------------------------------------------------------
# ™Sideview battle simple English version
#
#    (C) copyright by http://rye.jp/     Date 2007/01/12    Ver alpha
#--------------------------------------------------------------------------
#  Side view battle script walking graphic version      Special Thanks by blz
#--------------------------------------------------------------------------

#--------------------------------------------------------------------------
#  Standard of graphic file
#--------------------------------------------------------------------------
#  battler graphics
#
#  @Walking graphic is used as it is.
#  @
#  weapon graphics
#
#  @The icon graphic of arms is used as it is.
#


module Side_view
  #--------------------------------------------------------------------------
  # œ Using together RTAB@™Automatic recognition
  #--------------------------------------------------------------------------
  if Scene_Battle.method_defined?("synthe?")
    RTAB = true
  else
    RTAB = false
  end
  #--------------------------------------------------------------------------
  # œ Using together RTAB cam ™Automatic recognition
  #--------------------------------------------------------------------------
  def camera_correctness
    return false if !RTAB
    begin
      return $scene.drive
    rescue
      return false
    end
  end
  #--------------------------------------------------------------------------
  # œ The maximum number of parties
  #--------------------------------------------------------------------------
  Party_max = 4
  #--------------------------------------------------------------------------
  # œ Expansion rate of Battler graphic(actor exclusive use)
  #--------------------------------------------------------------------------
  CHAR_ZOOM = 1.0
  #--------------------------------------------------------------------------
  # œ Arrow cursor position correction
  #--------------------------------------------------------------------------
  ARROW_OX = 0
  ARROW_OY = 64
  #--------------------------------------------------------------------------
  # œ State name treated as flight (Array)
  #--------------------------------------------------------------------------
  FLY_STATES = ["Flying"]
  #--------------------------------------------------------------------------
  # œ Positional correction of combat screen party
  #--------------------------------------------------------------------------
  PARTY_X = 480     # X position of party
  PARTY_Y = 200     # Y position of party
  FORMATION_X = 32  # actor's interval X
  FORMATION_Y = 38  # actor's interval Y
  #--------------------------------------------------------------------------
  # œ ƒJƒXƒ^ƒ}ƒCƒY’è”
  #--------------------------------------------------------------------------
  NORMAL   = "NORMAL"
  WALK_R   = "WALK_R"
  WALK_L   = "WALK_L"
  ATTACK   = "ATTACK"
  ATTACK_R = "ATTACK_R"
  ATTACK_L = "ATTACK_L"
  MAGIC    = "MAGIC"
  ITEM     = "ITEM"
  # ƒAƒjƒ‚ÌÝ’è
  ANIME = {
    # [id,Loop?,speed,weapon visible,pattern freeze,Weapon Right or Left(using RTAB)]
    NORMAL            => [1,true , 0,false, true ,""    ], # Standby usually
    WALK_R            => [2,true , 6,false, false,""    ], # move Right
    WALK_L            => [1,true , 6,false, false,""    ], # move Left
    ATTACK_R          => [1,false, 6,true , false,"Right"],# attack by Right hand
    ATTACK_L          => [1,false, 6,true , false,"Left"], # attack by Left hand
    MAGIC             => [1,false, 6,false, false,""    ], # spell Magic
    ITEM              => [1,false, 6,false, false,""    ], # using Item
    }

  # default (Do not change it)
  ANIME.default = [1,false,12,false,"",""]

  # ƒAƒNƒVƒ‡ƒ“Ý’è‚ÌŠÖ˜A•t‚¯
  ACTION_LIB = {
    "Hero Move"            => "moving_setup",
    "Hero Graphic Change"  => "change",
    "Throw Animation"      => "flying",
    "main phase step 3"    => "animation1",
    "main phase step 4"    => "animation2",
    "Waiting"              => "wait",
    "Graphic Reverse"      => "reverse",
    "Afterimage ON"        => "shadow_on",
    "Afterimage OFF"       => "shadow_off",
    "Freeze ON"            => "freeze",
    "Freeze OFF"           => "freeze_lifting",
    "Display Animation"    => "animation_start",
    "Play Sound Effect"    => "play_se",
  }
  ACTION_LIB.default = "finish"

# (Do not change it)
  DUAL_WEAPONS_ANIME = [ATTACK]


# Arms display X coordinates
  BLZ_X = {
  0=>[0,0,0,0],   # NO MOTION
  1=>[2,2,2,2],   # Shake lowering
  2=>[15,10,0,0], # Piercing
  3=>[2,2,2,2],   # Raising
  4=>[0,0,3,3],   # Bow and gun
  5=>[0,0,0,0],   # For addition
  6=>[0,0,0,0],   # For addition
  7=>[0,0,0,0],   # For addition
  8=>[0,0,0,0],   # For addition
  }
  # Arms display Y coordinates
  BLZ_Y = {
  0=>[0,0,0,0], # NO MOTION
  1=>[6,6,6,6], # Shake lowering
  2=>[6,6,6,6], # Piercing
  3=>[6,6,6,6], # Raising
  4=>[8,8,8,8], # Bow and gun
  5=>[0,0,0,0], # For addition
  6=>[0,0,0,0], # For addition
  7=>[0,0,0,0], # For addition
  8=>[0,0,0,0], # For addition
  }
  # Arms display Angle
  BLZ_ANGLE = {
  0=>[0,0,0,0],                            # NO MOTION
  1=>[75-45*3,75-45*2,75-45*1,75-45*1],    # Shake lowering
  2=>[45,45,45,45],                        # Piercing
  3=>[100-45*1,100-45*2,100-45*3,00-45*4], # Raising
  4=>[45,45,45,45],                        # Bow and gun
  5=>[0,0,0,0],                            # For addition
  6=>[0,0,0,0],                            # For addition
  7=>[0,0,0,0],                            # For addition
  8=>[0,0,0,0],                            # For addition
  }

  #--------------------------------------------------------------------------
  # œ SHAKE
  #--------------------------------------------------------------------------
  SHAKE_FILE = "SHAKE"  # filename
  SHAKE_POWER = 5       # POWER
  SHAKE_SPEED = 5       # SPEED
  SHAKE_DURATION = 5    # DURATION
  #--------------------------------------------------------------------------
  # œ UPSIDE_DOWN
  #--------------------------------------------------------------------------
  UPSIDE_DOWN_FILE = "UPSIDE_DOWN" # filename
  #--------------------------------------------------------------------------
  # œ REVERSE
  #--------------------------------------------------------------------------
  REVERSE_FILE = "REVERSE" # filename
  #--------------------------------------------------------------------------
  # œ ‰ñ“]‚ÌÝ’è
  #--------------------------------------------------------------------------
  TURNING_FILE = "ROTATION" # filename
  TURNING_DIRECTION = 1     # Directioni1.Anti-clockwise, -1.clockwise)
  TURNING_SPEED = 40        # Speed
  TURNING_DURATION = 1      # Rotation frequency
  #--------------------------------------------------------------------------
  # œ ˆÚ“®‚ÌÝ’è
  #--------------------------------------------------------------------------
  MOVE_FILE = "MOVE"             # filename
  MOVE_RETURN = 1                # Do you return to former position?
  MOVE_SPEED = 32                # Speed
  MOVE_COORDINATES = [0,-640]    # Relative coordinates from former position
  #--------------------------------------------------------------------------
  # œ Add Animation (using RTAB)
  #--------------------------------------------------------------------------
  ADD_ANIME_FILE = "Add_ANIME"   # filename
  ADD_ANIME_ID = 0               # Animation ID
  #--------------------------------------------------------------------------
  # œ using RTAB (Do not change it)
  #--------------------------------------------------------------------------
  def convert_battler
    return RTAB ? @active_actor : @active_battler
  end
  #--------------------------------------------------------------------------
  # œ using RTAB (Do not change it)
  #--------------------------------------------------------------------------
  def convert_battler2(*arg)
    return RTAB ? arg[0] : @active_battler
  end
end

#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
module BattleActions

  # Because the one below is one example to the last
  # Please make it originally.

Actions = {

"Normal Attack" => [

  "main phase step 3",
  "Hero Graphic Change#WALK_L",
  "Hero Move#target,32,0,64,0",
  "Hero Graphic Change#NORMAL",
  "Waiting#5",
  "Hero Graphic Change#ATTACK",
  "Throw Animation",
  "main phase step 4",
  "Hero Graphic Change#WALK_L",
  "Play Sound Effect#016-Jump02,80,100",
  "Hero Move#self,0,0,18,4",
  "end"
  ],


  "One step advancement Attack" => [

  "main phase step 3",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,-32,0,12,0",
  "Hero Graphic Change#NORMAL",
  "Waiting#5",
  "Hero Graphic Change#ATTACK",
  "Throw Animation",
  "main phase step 4",
  "Hero Graphic Change#WALK_L",
  "Play Sound Effect#016-Jump02,80,100",
  "Hero Move#self,0,0,12,0",
  "end"
  ],

"Enemy Attack" => [

  "main phase step 3",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,-36,0,12,0",
  "Hero Graphic Change#NORMAL",
  "Waiting#5",
  "Hero Graphic Change#ATTACK",
  "Throw Animation",
  "main phase step 4",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,0,0,12,0",
  "end"
  ],


  "Spell Magic" => [

  "main phase step 3",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,-32,0,4,0",
  "Hero Graphic Change#MAGIC",
  "Waiting#15",
  "Throw Animation",
  "main phase step 4",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,0,0,4,2",
  "end"
  ],

"Using Item" => [

  "Hero Graphic Change#WALK_L",
  "Hero Move#self,-32,0,4,0",
  "main phase step 3",
  "Hero Graphic Change#ITEM",
  "Waiting#15",
  "Throw Animation",
  "main phase step 4",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,0,0,4,2",
  "end"
  ],

  "Using Skill" => [

  "Hero Graphic Change#WALK_L",
  "Hero Move#target_near,50,0,48,6",
  "Graphic Reverse",
  "Freeze ON#ATTACK#3",
  "main phase step 3",
  "Play Sound Effect#135-Light01,100,100",
  "Display Animation#self,42",
  "Waiting#15",
  "Graphic Reverse",
  "Afterimage ON",
  "Hero Move#target_far,-50,0,48,0",
  "main phase step 4",
  "Afterimage OFF",
  "Freeze OFF",
  "Hero Graphic Change#WALK_L",
  "Hero Move#self,0,0,48,1,0",
  "end"
  ],
  }

end

module RPG

# Because the one below is one example to the last
  # Please make it originally.

class Weapon
    #--------------------------------------------------------------------------
    # Weapon sctions. Set what weapons are a stand still weapon.
    #--------------------------------------------------------------------------
    def battle_actions
      case @id
      when 21 # Bronze Gun
        return BattleActions::Actions["One step advancement Attack"]
      end
      return BattleActions::Actions["Normal Attack"] # default
    end
  end
  class Skill
    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    def battle_actions
      if self.magic?
        return BattleActions::Actions["Spell Magic"] # default
      else
        return BattleActions::Actions["Using Skill"] # default
      end
    end
  end
  class Item
    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    def battle_actions
      return BattleActions::Actions["Using Item"] # default
    end
  end
end
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # œ action performer
  #--------------------------------------------------------------------------
  def battle_actions
    return BattleActions::Actions["Enemy Attack"] # default
  end
end
module RPG
=begin

  œ Setting of arms type

    The attribute of the name "WeaponType" is made, and it is applied to arms.
    The figure is written behind "WeaponType".
@@
    Example.@WeaponType1@

=end
  class Weapon
    #--------------------------------------------------------------------------
    # œ WeaponType
    #--------------------------------------------------------------------------
    def anime
      # Elemental
      element_name = "WeaponType"
      for i in @element_set
        if $data_system.elements[i] =~ /#{element_name}([+-]?[0-9]+)?(%)?/
          return $1.to_i
        end
      end
      # Weapon ID

# Because the one below is one example to the last
  # Please make it originally.

case @id
      when 1,2,3,4
        return 1 # (WeaponType) Refer from the 115th line to the 150th line.
      when 5,6,7,8
        return 2 # (WeaponType) Refer from the 115th line to the 150th line.
      end
      return 1 # defaut
    end
  end
end
=begin
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------

@  Animation is thrown out from performar to target.
    Please make animation from the data base.

[ Animation ID, Speed, Do you shuttle?, Straight line (false) or curve(true)]
=end
module RPG
  class Weapon
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
      # Example
      #case @id
      #when 34 # Boomerang
      #  return [10,32,true,true]
      #when 17,18,19,20 # Arrow
      #  return [40,32,false,false]
      #end
      return [0,0,false,false] # No throw
    end
  end
  class Skill
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
      # Example
      #case @id
      #when 34 # Boomerang
      #  return [10,32,true,true]
      #when 17,18,19,20 # Arrow
      #  return [40,32,false,false]
      #end
      return [0,0,false,false] # No throw
    end
  end
  class Item
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
      # Example
      #case @id
      #when 34 # Boomerang
      #  return [10,32,true,true]
      #when 17,18,19,20 # Arrow
      #  return [40,32,false,false]
      #end
      return [0,0,false,false] # No throw
    end
  end
end

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # œ Throw Animation
  #--------------------------------------------------------------------------
  def flying_anime
      # Example
      #case @id
      #when 34 # Boomerang
      #  return [10,32,true,true]
      #when 17,18,19,20 # Arrow
      #  return [40,32,false,false]
      #end
    return [0,0,false,false] # No throw
  end
end
#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
  include Side_view
  #--------------------------------------------------------------------------
  # œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
  #--------------------------------------------------------------------------
  attr_accessor :height                  # ‰æ‘œ‚Ì‚‚³
  attr_accessor :real_x                  # XÀ•W•â³
  attr_accessor :real_y                  # YÀ•W•â³
  attr_accessor :real_zoom               # Šg‘å—¦
  attr_accessor :wait_count              # ƒAƒjƒ[ƒVƒ‡ƒ“ ‘Ò‚¿ŽžŠÔ
  attr_accessor :wait_count2             # ƒAƒjƒ[ƒVƒ‡ƒ“ ‘Ò‚¿ŽžŠÔ2
  attr_accessor :pattern                 # ƒAƒjƒ[ƒVƒ‡ƒ“ ƒJƒEƒ“ƒgiƒLƒƒƒ‰)
  attr_accessor :shake                   # ƒVƒFƒCƒNŠJŽnƒtƒ‰ƒbƒO
  attr_accessor :reverse                 # ¶‰E”½“]ƒtƒ‰ƒbƒO
  attr_accessor :shadow                  # Žc‘œƒtƒ‰ƒbƒO
  attr_accessor :flash_flag              # ‘M‚«ƒtƒ‰ƒbƒO
  attr_reader   :ox                      # XÀ•W•â³
  attr_reader   :oy                      # YÀ•W•â³
  attr_reader   :flying_x                # ‰“‹——£ƒAƒjƒXÀ•W
  attr_reader   :flying_y                # ‰“‹——£ƒAƒjƒYÀ•W
  attr_reader   :flying_anime            # ‰“‹——£ƒAƒjƒ
  attr_reader   :animation1_on           # s“®ƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
  attr_reader   :animation2_on           # ‘ÎÛƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
  #--------------------------------------------------------------------------
  # œ ƒfƒtƒHƒ‹ƒg‚̃Aƒjƒ[ƒVƒ‡ƒ“‘Ò‚¿ŽžŠÔ‚ðŽæ“¾
  #--------------------------------------------------------------------------
  def animation_duration=(animation_duration)
    @_animation_duration = animation_duration
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹ŠJŽnŽž‚̃ZƒbƒgƒAƒbƒv
  #--------------------------------------------------------------------------
  def start_battle
    @height = 0
    @real_x = 0
    @real_y = 0
    @real_zoom = 1.0
    @battler_condition = ""
    @action = nil
    @battle_actions = []
    @battler_action = false
    @step = 0
    @anime_on = false
    @wait_count = 0
    @wait_count2 = 0
    @ox = 0
    @oy = 0
    @pattern = 0
    @pattern_log = true
    @pattern_freeze = false
    @condition_freeze = false
    @active = false
    @move_distance = nil
    @move_wait = 0
    @move_coordinates = [0,0,0,0]
    @flying_distance = nil
    @flying_wait = 0
    @flying_x = 0
    @flying_y = 0
    @flash_flag = {}
    self.flying_clear
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®’†”»’è
  #--------------------------------------------------------------------------
  def moving?
    # XÀ•W•â³‚Ü‚½‚ÍAYÀ•W•â³‚ª0‚Å‚È‚¯‚ê‚ÎAˆÚ“®’†
    return (@ox != 0 or @oy != 0)
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®I—¹”»’è
  #--------------------------------------------------------------------------
  def move_end?
    return (@ox == @move_coordinates[0] and @oy == @move_coordinates[1])
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒVƒ‡ƒ“ŠJŽnÝ’è
  #--------------------------------------------------------------------------
  def action(flag = true)
    @battler_action = flag
    @animation1_on = false
    @animation2_on = false
    @step = "setup"
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒVƒ‡ƒ“’†”»’è
  #--------------------------------------------------------------------------
  def action?
    return @battler_action
  end
  #--------------------------------------------------------------------------
  # œ ‘M‚«”»’è
  #--------------------------------------------------------------------------
  def flash?
    return @flash_flg
  end
  #--------------------------------------------------------------------------
  # œ 퓬•s”\”»’è
  #--------------------------------------------------------------------------
  def anime_dead?
    if $game_temp.in_battle and !RTAB
      if [2,3,4,5].include?($scene.phase4_step)
        return @last_dead
      end
    end
    return @last_dead = self.dead?
  end
  #--------------------------------------------------------------------------
  # œ ƒsƒ“ƒ`ó‘Ô”»’è
  #--------------------------------------------------------------------------
  def crisis?
    if $game_temp.in_battle and !RTAB
      if [2,3,4,5].include?($scene.phase4_step)
        return @last_crisis
      end
    end
    return @last_crisis = (self.hp <= self.maxhp / 4 or badstate?)
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒbƒhƒXƒe[ƒg”»’è
  #--------------------------------------------------------------------------
  def badstate?
    for i in @states
      unless $data_states[i].nonresistance
        return true
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # œ ”òs
  #--------------------------------------------------------------------------
  def fly
    if @fly != nil
      return @fly
    end
    for id in @states
      if FLY_STATES.include?($data_states[id].name)
        return 60
      end
    end
    return 0
  end
  #--------------------------------------------------------------------------
  # œ ‰“‹——£ƒAƒjƒ–Ú•WÀ•W‚ÌŒvŽZ
  #--------------------------------------------------------------------------
  def flying_setup
    # “ñ“x–Ú‚ÍŽÀs‚µ‚È‚¢
    return if @flying_distance != nil && !camera_correctness
    if RTAB
      targets = @target
    else
      targets = $scene.target_battlers
    end
    # –Ú“IÀ•W‚ðŒvŽZ
    @f_target_x = 0
    @f_target_y = 0
    for t in targets
      @f_target_x += t.screen_x
      @f_target_y += t.screen_y
    end
    if targets != []
      @f_target_x /= targets.size
      @f_target_y /= targets.size
    else
      @flying_distance = 0
      return
    end
    # ‹——£‚ÌŒvŽZ
    @flying_distance = (self.screen_x - @f_target_x).abs + (self.screen_y - @f_target_y).abs
    @flying_end = false
  end
  #--------------------------------------------------------------------------
  # œ ‰“‹——£ƒAƒjƒ
  #--------------------------------------------------------------------------
  def flying_animation
    # –ß‚é
    if @step != "flying" or @flying_distance.nil?
      return [false,true]
    end
    # ‚ ‚ç‚©‚¶‚ߌvŽZ
    self_x = self.screen_x
    self_y = self.screen_y
    @flying_distance = @flying_distance == 0 ? 1 : @flying_distance
    n1 = @flying_wait / @flying_distance.to_f
    if @flying_distance - @flying_wait > @flying_distance / 2
      n2 = 1.0 + 10.0 * @flying_wait / @flying_distance.to_f
    else
      n2 = 1.0 + 10.0 * (@flying_distance - @flying_wait) / @flying_distance.to_f
    end
    if !@flying_anime[4]
      # ’¼üˆÚ“®
      x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
      y = (self_y + 1.0 * (@f_target_y - self_y) * n1).to_i
    else
      # ‹ÈüˆÚ“®
      if !@flying_proceed_end
        x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
        y = (self_y + 1.0 * (@f_target_y - self_y) * n1 - n2**2).to_i
      else
        x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
        y = (self_y + 1.0 * (@f_target_y - self_y) * n1 + n2**2).to_i
      end
    end
    # À•W‘ã“ü
    @flying_x = x
    @flying_y = y
    # ƒEƒGƒCƒg
    if !@flying_proceed_end
      # ŠJŽn
      @flying_proceed_start = @flying_wait == 0
      @flying_wait += @flying_anime[1]
      @flying_wait = [@flying_wait,@flying_distance].min
      @flying_proceed_end = @flying_wait == @flying_distance
    else
      # ŠJŽn
      @flying_return_start = @flying_wait == @flying_distance
      @flying_wait -= @flying_anime[1]
      @flying_wait = [@flying_wait,0].max
      @flying_return_end = @flying_wait == 0
    end
    if @flying_anime[1] == 0
      @flying_end = true
    elsif !@flying_anime[2]
      @flying_end = @flying_proceed_end
    else
      @flying_end = @flying_return_end
    end
    # ’l‚ð•Ô‚·iƒAƒjƒŠJŽn,ƒAƒjƒI—¹)
    return [@flying_proceed_start,@flying_end]
  end
  #--------------------------------------------------------------------------
  # œ ‰“‹——£ƒAƒjƒ‰Šú‰»
  #--------------------------------------------------------------------------
  def flying_clear
    @flying_proceed_start = false
    @flying_proceed_end = false
    @flying_return_start = false
    @flying_return_end = false
    @flying_end = true
    @flying_anime = [0,0,false,false]
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®
  #--------------------------------------------------------------------------
  def move
    # ‹——£‚ÌŒvŽZ
    @move_distance = (@move_coordinates[2] - @move_coordinates[0]).abs +
                     (@move_coordinates[3] - @move_coordinates[1]).abs
    if @move_distance > 0
      return if @ox == @move_coordinates[0] and @oy == @move_coordinates[1]
      array = @move_coordinates
      # ƒWƒƒƒ“ƒv•â³’l‚ÌŒvŽZ
      n = 100.0 * @move_wait / @move_distance
      jump = -@move_action[4] * n * (100 - n) / 100.0
      @ox = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @move_wait) / @move_distance.to_f).to_i
      @oy = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @move_wait) / @move_distance.to_f + jump).to_i
      # ƒEƒGƒCƒg
      @move_wait -= @move_action[3]
      @move_wait = [@move_wait,0].max
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®ƒAƒNƒVƒ‡ƒ“‚̎擾
  #--------------------------------------------------------------------------
  def get_move_action
    string = @action.split(/#/)[1]
    string = string.split(/,/)
    @move_action = [string[0],string[1].to_i,string[2].to_i,string[3].to_i,string[4].to_i,string[5].to_i]
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒVƒ‡ƒ“‚̎擾
  #--------------------------------------------------------------------------
  def get_step
    if @action.nil?
      @step = "finish"
      return
    end
    return ACTION_LIB[@action.split(/#/)[0]]
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ŽŸ‚̃AƒNƒVƒ‡ƒ“‚Ö)
  #--------------------------------------------------------------------------
  def update_next
    @action = @battle_actions.shift
    @step = get_step
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (“®ìŽæ“¾)
  #--------------------------------------------------------------------------
  def update_setup
    # ƒAƒNƒVƒ‡ƒ“‚̎擾
    self.get_actions
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ˆÚ“®Žæ“¾)
  #--------------------------------------------------------------------------
  def update_moving_setup
    # ˆÚ“®ƒAƒNƒVƒ‡ƒ“‚̎擾
    self.get_move_action
    # ˆÚ“®–Ú•W‚ÌÝ’è
    self.move_setup
    @step = "moving"
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ˆÚ“®)
  #--------------------------------------------------------------------------
  def update_moving
    # ˆÚ“®
    self.move
    self.condition = @battler_condition
    # ˆÚ“®Š®—¹‚µ‚½‚玟‚̃Xƒeƒbƒv‚Ö
    if move_end?
      update_next
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒŽÀs)
  #--------------------------------------------------------------------------
  def update_action
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
      if !@first_weapon and @second_weapon
        con = con + "_L"
      else
        con = con + "_R"
      end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    # ƒ‹[ƒv‚©”Û‚©
    if !ANIME[@battler_condition][1]
      self.anime_on
    end
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (‰“‹——£ƒAƒjƒ)
  #--------------------------------------------------------------------------
  def update_flying
    # –Ú•W‚ÌÝ’è
    self.flying_setup
    # ‰“‹——£ƒAƒjƒI—¹
    if @flying_end or @flying_anime == [0,0,false,false]
      self.flying_clear
      update_next
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ•ÏX)
  #--------------------------------------------------------------------------
  def update_change
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
      if !@first_weapon and @second_weapon
        con = con + "_L"
      else
        con = con + "_R"
      end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    # ƒ‹[ƒv‚©”Û‚©
    if !ANIME[@battler_condition][1]
      self.anime_on
    end
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (s“®ƒAƒjƒ)
  #--------------------------------------------------------------------------
  def update_animation1
    @animation1_on = true
    # s“®ƒAƒjƒ‚ÌŒã‚És“®‚ðŠJŽn‚·‚é
    if $scene.phase4_step == 3
      id = RTAB ? @anime1 : $scene.animation1_id
      animation = $data_animations[id]
      frame_max = animation != nil ? animation.frame_max : 0
      @wait_count2 = frame_max * 2
      return
    end
    update_next
  end
#--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒEƒGƒCƒg)
  #--------------------------------------------------------------------------
  def update_wait
    @wait_count2 = @action.split(/#/)[1].to_i
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (Žc‘œ•\Ž¦)
  #--------------------------------------------------------------------------
  def update_shadow_on
    @shadow = true
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (Žc‘œÁ‹Ž)
  #--------------------------------------------------------------------------
  def update_shadow_off
    @shadow = false
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (¶‰E”½“])
  #--------------------------------------------------------------------------
  def update_reverse
    @reverse = @reverse ? false : true
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (‘M‚«ƒAƒjƒ)
  #--------------------------------------------------------------------------
  def update_flash
    # ‘M‚«ƒAƒjƒ‚ÌŒã‚És“®‚ðŠJŽn‚·‚é
    if @flash_flag["normal"]
      @wait_count = $scene.flash_duration
      @flash_flag["normal"] = false
      return
    end
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (SE‚̉‰‘t)
  #--------------------------------------------------------------------------
  def update_play_se
    data = @action.split(/#/)[1]
    data = data.split(/,/)
    # SE ‚ð‰‰‘t
    Audio.se_play("Audio/SE/" + data[0], data[1].to_i, data[2].to_i)
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ’è)
  #--------------------------------------------------------------------------
  def update_freeze
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
      if !@first_weapon and @second_weapon
        con = con + "_L"
      else
        con = con + "_R"
      end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    @pattern = @action.split(/#/)[2].to_i
    @pattern_freeze = true
    @condition_freeze = true
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ’è‰ðœ)
  #--------------------------------------------------------------------------
  def update_freeze_lifting
    @pattern_freeze = false
    @condition_freeze = false
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ[ƒVƒ‡ƒ“‚Ì•\Ž¦)
  #--------------------------------------------------------------------------
  def update_animation_start
    data = @action.split(/#/)[1]
    data = data.split(/,/)
    target = data[0]
    animation_id = data[1].to_i
    if RTAB
      case target
      when "self"
        @animation.push([animation_id,true])
      when "target"
        for tar in @target
          tar.animation.push([animation_id, true])
        end
      end
    else
      case target
      when "self"
        @animation_id = animation_id
        @animation_hit = true
      when "target"
        for tar in $scene.target_battlers
          tar.animation_id = animation_id
          tar.animation_hit = true
        end
      end
    end
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (“®ìI—¹)
  #--------------------------------------------------------------------------
  def update_finish
    # “®ìI—¹
    @battler_action = false
    @step = "setup"
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‰[‚Ìó‘Ôiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN‚̃^ƒCƒv)
  #--------------------------------------------------------------------------
  def condition
    return @battler_condition
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‰[‚Ìó‘Ô •ÏXiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN‚̃^ƒCƒv)
  #--------------------------------------------------------------------------
  def condition=(condition)
    return if @condition_freeze
    if @battler_condition != condition
      @wait_count = ANIME[condition][2]
      @pattern = 0
    end
    @battler_condition = condition
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    # ƒEƒFƒCƒg’†‚Ìê‡
    if @wait_count == 0
      # ƒpƒ^[ƒ“XV
      self.char_animation
      @wait_count = ANIME[@battler_condition][2]
    end
    # ƒpƒ^[ƒ“XV
    self.char_animation
    # ƒEƒFƒCƒg’†‚Ìê‡
    if @wait_count2 > 0
      return
    end

    # s“®ƒAƒjƒ[ƒVƒ‡ƒ“
    if @battler_action
      method("update_" + @step).call
      return
    end

    # ƒf[ƒ^‰Šú‰»
    @animation1_on = false
    @animation2_on = false
    @action = nil
    @battle_actions = []
    @move_wait = 0
    @move_distance = nil
    @flying_wait = 0
    @flying_distance = nil
    @flash = false

# ’ÊíE‘Ò‹@
    return self.condition = NORMAL
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒVƒ‡ƒ“‚̎擾
  #--------------------------------------------------------------------------
  def get_actions
    skill = $data_skills[self.current_action.skill_id]
    item = $data_items[self.current_action.item_id]
    kind = self.current_action.kind
    # “®ìŽæ“¾
    @battle_actions = []
    # ƒXƒLƒ‹
    if skill != nil && kind == 1
      @battle_actions = skill.battle_actions.dup
      @flying_anime = skill.flying_anime
    # ƒAƒCƒeƒ€
    elsif item != nil && kind == 2
      @battle_actions = item.battle_actions.dup
      @flying_anime = item.flying_anime
    # ¶ŽèUŒ‚
    elsif !@first_weapon and @second_weapon and self.is_a?(Game_Actor)
      @battle_actions = self.battle_actions2.dup
      @flying_anime = self.flying_anime2
    # ‰EŽèUŒ‚
    elsif self.current_action.basic == 0 and
      self.is_a?(Game_Actor) and self.current_action.kind == 0
      @battle_actions = self.battle_actions1.dup
      @flying_anime = self.flying_anime1
    # ’ÊíUŒ‚
    elsif self.current_action.basic == 0 and self.current_action.kind == 0
      @battle_actions = self.battle_actions.dup
      @flying_anime = self.flying_anime
    else
      @battle_actions = ["I—¹"]
      @flying_anime = [0,0,false,false]
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒ‹[ƒv‚µ‚È‚¢ƒAƒjƒ‚̃Zƒbƒg
  #--------------------------------------------------------------------------
  def anime_on
    @pattern = 0
    @pattern_log = true
    return
  end
  #--------------------------------------------------------------------------
  # œ ƒpƒ^[ƒ“XV
  #--------------------------------------------------------------------------
  def char_animation
    # ƒpƒ^ƒ“ŒÅ’è‚Ìꇂà‚Ç‚é
    return if @pattern_freeze
    # ƒ‹[ƒv‚µ‚È‚¢ƒAƒjƒ‚Ìê‡ 1234 ‚ÅŽ~‚Ü‚é
    if !ANIME[@battler_condition][1] && @pattern == 3
      return
    end
    # ƒAƒjƒ‚³‚¹‚È‚¢ê‡ 1 ‚ÅŽ~‚Ü‚é
    if ANIME[@battler_condition][4]
      @pattern = 0
      return
    end
    @pattern = (@pattern + 1) % 4
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒƒ^ƒCƒv
  #--------------------------------------------------------------------------
  def anime_type
    return ANIME[@battler_condition] != nil ? ANIME[@battler_condition][0] : 0
  end
end
#==============================================================================
# ¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒZƒbƒgƒAƒbƒv
  #--------------------------------------------------------------------------
  alias side_view_setup setup
  def setup(actor_id)
    side_view_setup(actor_id)
    start_battle
  end
  #--------------------------------------------------------------------------
  # œ “ñ“•Ší‚ÌIDŽæ“¾@¦ƒGƒ‰[‰ñ”ð—p
  #--------------------------------------------------------------------------
  def weapon2_id
    return @weapon2_id != nil ? @weapon2_id : 0
  end
  #--------------------------------------------------------------------------
  # œ X•ûŒü ƒ|ƒWƒVƒ‡ƒ“ Žæ“¾
  #--------------------------------------------------------------------------
  def position
    return $data_classes[@class_id].position
  end
  #--------------------------------------------------------------------------
  # œ Y•ûŒü ƒ|ƒWƒVƒ‡ƒ“ Žæ“¾
  #--------------------------------------------------------------------------
  def position2
    return self.index
  end
  #--------------------------------------------------------------------------
  # œ •ŠíƒAƒjƒƒ^ƒCƒv
  #--------------------------------------------------------------------------
  def weapon_anime_type(type = @battler_condition)
    file_name  = weapon_anime_type0(type)
    visible   = weapon_anime_type1(type)
    z         = weapon_anime_type2(type)
    motion    = weapon_anime_type3(type)
    return [file_name,visible,z,motion]
  end
  # •ŠíƒAƒCƒRƒ“Žæ“¾
  def weapon_anime_type0(type = @battler_condition)
    type = ANIME[type][5]
    return weapon_anime1 if type == "Right"
    return weapon_anime2 if type == "Left"
    return nil
  end
  # •\Ž¦E”ñ•\Ž¦‚̎擾
  def weapon_anime_type1(type = @battler_condition)
    return ANIME[type][3]
  end
  # ƒoƒgƒ‰[‚æ‚èã‚É•\Ž¦‚·‚é‚©‚Ç‚¤‚©
  def weapon_anime_type2(type = @battler_condition)
    type = ANIME[type][5]
    return true if type == "Left"
    return false
  end
  # •Ší‚Ì“®ìNoDŽæ“¾
  def weapon_anime_type3(type = @battler_condition)
    type = ANIME[type][5]
    return extend_weapon_anime1 if type == "Right"
    return extend_weapon_anime2 if type == "Left"
    return 0
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
  #--------------------------------------------------------------------------
  def true_x
    return PARTY_X + position * FORMATION_X + @ox
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
  #--------------------------------------------------------------------------
  def true_y
    # ƒp[ƒeƒB“à‚Ì•À‚ч‚©‚ç Y À•W‚ðŒvŽZ‚µ‚Ä•Ô‚·
    if self.index != nil
      y = position2 * FORMATION_Y + PARTY_Y + @oy - @height / 2
      return y
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_x(true_x = self.true_x)
    return 320 + (true_x - 320) * @real_zoom + @real_x
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_y(true_y = self.true_y)
    return true_y * @real_zoom + @real_y
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Z À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_z
    return screen_y + 1000
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
  #--------------------------------------------------------------------------
  def base_x
    return 320 + (true_x - @ox - 320) * @real_zoom + @real_x
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
  #--------------------------------------------------------------------------
  def base_y
    return (true_y - @oy) * @real_zoom + @real_y
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Šg‘å—¦‚̎擾
  #--------------------------------------------------------------------------
  def zoom
    return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) *
                          (true_x + @fly) / 480 + $scene.zoom_rate[0]
  end
  #--------------------------------------------------------------------------
  # œ UŒ‚—pAƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
  #--------------------------------------------------------------------------
  def attack_x(z)
    return (320 - true_x) * z * 0.75
  end
  #--------------------------------------------------------------------------
  # œ UŒ‚—pAƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
  #--------------------------------------------------------------------------
  def attack_y(z)
    return (160 - (true_y + fly / 4) * z + @height * zoom * z / 2) * 0.75
  end
  #--------------------------------------------------------------------------
  # œ ‘M‚«‘Ò‚¿ŽžŠÔ
  #--------------------------------------------------------------------------
  def flash_duration
    return $scene.flash_duration
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def battle_actions1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.battle_actions : BattleActions::Actions["’ÊíUŒ‚"]
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def battle_actions2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.battle_actions : BattleActions::Actions["’ÊíUŒ‚"]
  end
  #--------------------------------------------------------------------------
  # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“ “®‚«•û Žæ“¾
  #--------------------------------------------------------------------------
  def extend_weapon_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.anime : 0
  end
  #--------------------------------------------------------------------------
  # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“ “®‚«•û Žæ“¾
  #--------------------------------------------------------------------------
  def extend_weapon_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.anime : 0
  end
  #--------------------------------------------------------------------------
  # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def weapon_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.icon_name : ""
  end
  #--------------------------------------------------------------------------
  # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def weapon_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.icon_name : ""
  end
  #--------------------------------------------------------------------------
  # œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def flying_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.flying_anime : [0,0,false,false]
  end
  #--------------------------------------------------------------------------
  # œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
  #--------------------------------------------------------------------------
  def flying_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.flying_anime : [0,0,false,false]
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
  #--------------------------------------------------------------------------
  def move_setup
    if RTAB
      targets = @target
    else
      targets = $scene.target_battlers
    end
    case @move_action[0]
    when "self" # Ž©•ª
      @target_x = self.base_x
      @target_y = self.base_y
    when "target_near" # ˆê”Ô‹ß‚­‚̃^[ƒQƒbƒg
      targets.sort!{|a,b| a.screen_x<=>b.screen_x }
      targets.reverse!
      if targets != []
        @target_x = targets[0].screen_x
        @target_y = targets[0].screen_y
      else
        @target_x = self.base_x
        @target_y = self.base_y
      end
    when "target_far" # ˆê”Ô‰“‚­‚̃^[ƒQƒbƒg
      targets.sort!{|a,b| a.screen_x<=>b.screen_x }
      if targets != []
        @target_x = targets[0].screen_x
        @target_y = targets[0].screen_y
      else
        @target_x = self.base_x
        @target_y = self.base_y
      end
    when "target" # ƒ^[ƒQƒbƒg’†‰›
      @target_x = 0
      @target_y = 0
      for t in targets
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if targets != []
        @target_x /= targets.size
        @target_y /= targets.size
      end
    when "troop" # "ƒgƒ‹[ƒv’†‰›"
      @target_x = 0
      @target_y = 0
      for t in $game_troop.enemies
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if $game_troop.enemies != []
        @target_x /= $game_troop.enemies.size
        @target_y /= $game_troop.enemies.size
      end
    when "party" # "ƒp[ƒeƒB’†‰›"
      @target_x = 0
      @target_y = 0
      for t in $game_party.actors
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if $game_party.actors != []
        @target_x /= $game_party.actors.size
        @target_y /= $game_party.actors.size
      end
    when "screen" # "‰æ–Ê"
      @target_x = self.base_x
      @target_y = self.base_y
    end
    # •â³
    @target_x += @move_action[1] - self.base_x
    @target_y += @move_action[2] - self.base_y
    # ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
    @move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
    # ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
    @move_wait     = (@move_coordinates[2] - @move_coordinates[0]).abs +
                     (@move_coordinates[3] - @move_coordinates[1]).abs
  end
end
#==============================================================================
# ¡ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # œ ƒZƒbƒgƒAƒbƒv
  #--------------------------------------------------------------------------
  alias side_view_initialize initialize
  def initialize(troop_id, member_index)
    side_view_initialize(troop_id, member_index)
    start_battle
  end
  def character_name
    return battler_name
  end
  def character_hue
    return battler_hue
  end
  def reverse
    return !@reverse
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®
  #--------------------------------------------------------------------------
  def move
    # ‹——£‚ÌŒvŽZ
    @move_distance = (@move_coordinates[2] - @move_coordinates[0]).abs +
                     (@move_coordinates[3] - @move_coordinates[1]).abs
    if @move_distance > 0
      return if @ox == @move_coordinates[0] and @oy == @move_coordinates[1]
      array = @move_coordinates
      # ƒWƒƒƒ“ƒv•â³’l‚ÌŒvŽZ
      n = 100.0 * @move_wait / @move_distance
      jump = -@move_action[4] * n * (100 - n) / 100.0
      @ox = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @move_wait) / @move_distance.to_f).to_i
      @oy = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @move_wait) / @move_distance.to_f + jump).to_i
      # ƒEƒGƒCƒg
      @move_wait -= @move_action[3]
      @move_wait = [@move_wait,0].max
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
  #--------------------------------------------------------------------------
  def move_setup
    if RTAB
      targets = @target
    else
      targets = $scene.target_battlers
    end
    case @move_action[0]
    when "self" # Ž©•ª
      @target_x = self.base_x
      @target_y = self.base_y
    when "target_near" # ˆê”Ô‹ß‚­‚̃^[ƒQƒbƒg
      targets.sort!{|a,b| a.screen_x<=>b.screen_x }
      if targets != []
        @target_x = targets[0].screen_x
        @target_y = targets[0].screen_y
      else
        @target_x = self.base_x
        @target_y = self.base_y
      end
    when "target_far" # ˆê”Ô‰“‚­‚̃^[ƒQƒbƒg
      targets.sort!{|a,b| a.screen_x<=>b.screen_x }
      targets.reverse!
      if targets != []
        @target_x = targets[0].screen_x
        @target_y = targets[0].screen_y
      else
        @target_x = self.base_x
        @target_y = self.base_y
      end
    when "target" # ƒ^[ƒQƒbƒg’†‰›
      @target_x = 0
      @target_y = 0
      for t in targets
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if targets != []
        @target_x /= targets.size
        @target_y /= targets.size
      end
    when  "party" # "ƒgƒ‹[ƒv’†‰›"
      @target_x = 0
      @target_y = 0
      for t in $game_troop.enemies
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if $game_troop.enemies != []
        @target_x /= $game_troop.enemies.size
        @target_y /= $game_troop.enemies.size
      end
    when "troop" # "ƒp[ƒeƒB’†‰›"
      @target_x = 0
      @target_y = 0
      for t in $game_party.actors
        @target_x += t.screen_x
        @target_y += t.screen_y
      end
      if $game_party.actors != []
        @target_x /= $game_party.actors.size
        @target_y /= $game_party.actors.size
      end
    when "screen" # "‰æ–Ê"
      @target_x = self.base_x
      @target_y = self.base_y
    end
    # •â³
    @target_x -= @move_action[1] + self.base_x
    @target_y -= @move_action[2] + self.base_y
    # ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
    @move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
    # ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
    @move_wait     = (@move_coordinates[2] - @move_coordinates[0]).abs +
                     (@move_coordinates[3] - @move_coordinates[1]).abs
  end
  if RTAB
  alias original_x true_x
  alias original_y true_y
  else
  alias original_x screen_x
  alias original_y screen_y
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
  #--------------------------------------------------------------------------
  def true_x
    return original_x + @ox
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
  #--------------------------------------------------------------------------
  def true_y
    return original_y - @height / 2 + @oy
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_x(true_x = self.true_x)
    return true_x * @real_zoom + @real_x
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_y(true_y = self.true_y)
    return true_y * @real_zoom + @real_y
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
  #--------------------------------------------------------------------------
  def base_x(true_x = self.true_x)
    return (true_x - @ox) * @real_zoom + @real_x
  end
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
  #--------------------------------------------------------------------------
  def base_y(true_y = self.true_y)
    return (true_y - @oy) * @real_zoom + @real_y
  end
end
#==============================================================================
# ¡ Game_Party
#==============================================================================
class Game_Party
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒ^[‚ð‰Á‚¦‚é
  #     actor_id : ƒAƒNƒ^[ ID
  #--------------------------------------------------------------------------
  alias side_view_add_actor add_actor
  def add_actor(actor_id)
    # ƒAƒNƒ^[‚ðŽæ“¾
    actor = $game_actors[actor_id]
    # ƒTƒCƒhƒrƒ…[ƒf[ƒ^‚̉Šú‰»
    actor.start_battle
    # –ß‚·
    side_view_add_actor(actor_id)
  end
end
#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
  include Side_view
  #--------------------------------------------------------------------------
  # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
  #--------------------------------------------------------------------------
  attr_reader   :phase            # ƒtƒF[ƒY
  attr_reader   :phase4_step      # ƒtƒF[ƒY‚SƒXƒeƒbƒv
  attr_reader   :active_battler   # ‘ÎÛ‚Ì”z—ñ
  attr_reader   :target_battlers  # ‘ÎÛ‚Ì”z—ñ
  attr_reader   :animation1_id    # s“®ƒAƒjƒID
  attr_reader   :animation2_id    # ‘ÎÛƒAƒjƒID
  #--------------------------------------------------------------------------
  # œ ƒƒCƒ“ˆ—
  #--------------------------------------------------------------------------
  alias side_view_main main
  def main
    # ƒoƒgƒ‰[‰Šú‰»
    for battler in $game_party.actors + $game_troop.enemies
      battler.start_battle
    end
    # –ß‚·
    side_view_main
  end
  #--------------------------------------------------------------------------
  # œ ‘M‚«”»’è
  #--------------------------------------------------------------------------
  def flash?
    return @flash_flag ? true : false
  end
  #--------------------------------------------------------------------------
  # œ ‘M‚«ƒAƒjƒ‘Ò‚¿ŽžŠÔŽæ“¾
  #--------------------------------------------------------------------------
  def flash_duration
    animation = nil
    if FLASH_ANIME
      animation = $data_animations[FLASH_ANIMATION_ID]
    end
    return animation != nil ? animation.frame_max * 2 + 2 : 0
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
  #--------------------------------------------------------------------------
  alias side_view_update_phase4_step2 update_phase4_step2
  def update_phase4_step2(*arg)
    battler = convert_battler2(*arg)
    battler.action
    side_view_update_phase4_step2(*arg)
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 3 : s“®‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
  #--------------------------------------------------------------------------
  alias side_view_update_phase4_step3 update_phase4_step3
  def update_phase4_step3(*arg)
    battler = convert_battler2(*arg)
    return if !battler.animation1_on and battler.action? and !battler.flash?
    if battler.flash? and FLASH_ANIME
      battler.flash_flag["normal"] = true
    end
    side_view_update_phase4_step3(*arg)
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 4 : ‘ÎÛ‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
  #--------------------------------------------------------------------------
  alias side_view_update_phase4_step4 update_phase4_step4
  def update_phase4_step4(*arg)
    battler = convert_battler2(*arg)
    targets = RTAB ? battler.target : @target_battlers
    return if !battler.animation2_on and battler.action?
    side_view_update_phase4_step4(*arg)
    for target in targets
      if RTAB
        value = nil
        if target.damage_sp.include?(battler)
          value = target.damage_sp[battler]
        end
        if target.damage.include?(battler)
          if value == nil or value == "Miss"
            value = target.damage[battler]
          elsif value.is_a?(Numeric) && value > 0
            value = target.damage[battler] == "Miss" ? value : target.damage[battler]
          end
        end
      else
        value = target.damage
      end
      if target.is_a?(Game_Actor)
        # ƒ_ƒ[ƒW‚Ìê‡
        if value.is_a?(Numeric) && value > 0
          # ƒVƒFƒCƒN‚ðŠJŽn
          target.shake = true
        end
      elsif target.is_a?(Game_Enemy)
        # ƒ_ƒ[ƒW‚Ìê‡
        if value.is_a?(Numeric) && value > 0
          # ƒVƒFƒCƒN‚ðŠJŽn
          target.shake = true
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒvƒŒƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
  #--------------------------------------------------------------------------
  alias start_phase1_correct start_phase1
  def start_phase1
    # ƒJƒƒ‰‚ÌÝ’è
    # Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
    @zoom_rate = [1.0, 1.0]
    start_phase1_correct
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
  #--------------------------------------------------------------------------
  alias start_phase3_correct start_phase3
  def start_phase3
    battler = convert_battler
    start_phase3_correct
    if RTAB
      # ƒJƒƒ‰‚ÌÝ’è
      # Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
      @camera = "command"
      @spriteset.screen_target(0, 0, 1.0)
    end
  end
end

class Spriteset_Battle
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
  #--------------------------------------------------------------------------
  alias side_veiw_initialize initialize
  def initialize
    side_veiw_initialize
    # ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ð‰ð•ú
    for sprite in @actor_sprites
      sprite.dispose
    end
    # ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ðì¬
    @actor_sprites = []
    for i in 1..Party_max
      @actor_sprites.push(Sprite_Battler.new(@viewport1))
    end
    update
  end
  #--------------------------------------------------------------------------
  # œ ‰æ–ʂ̃XƒNƒ[ƒ‹
  #--------------------------------------------------------------------------
  if method_defined?("screen_scroll")
  alias side_view_screen_scroll screen_scroll
  def screen_scroll
    side_view_screen_scroll
    # ƒAƒNƒ^[‚̈ʒu•â³
    for actor in $game_party.actors
      actor.real_x = @real_x
      actor.real_y = @real_y
      actor.real_zoom = @real_zoom
    end
  end
  end
end

class Sprite_Battler < RPG::Sprite
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
  #     viewport : ƒrƒ…[ƒ|[ƒg
  #     battler  : ƒoƒgƒ‰[ (Game_Battler)
  #--------------------------------------------------------------------------
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @weapon = Sprite_Weapon.new(viewport, battler)
    @flying = Sprite_Flying.new(viewport, battler)
    @shadow = []
    @fly = 0
    @fly_direction = 1
    @rand = rand(10)
    @bitmaps = {}
    self.effect_clear
  end
  #--------------------------------------------------------------------------
  # œ ‰ð•ú
  #--------------------------------------------------------------------------
  alias side_view_dispose dispose
  def dispose
    side_view_dispose
    @weapon.dispose if @weapon != nil
    @flying.dispose if @flying != nil
    if @_target_sprite != nil
      @_target_sprite.bitmap.dispose
      @_target_sprite.dispose
      @_target_sprite = nil
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil
      self.bitmap = nil
      @weapon.bitmap = nil
      loop_animation(nil)
      return
    end
    # ƒoƒgƒ‰[XV
    @battler.update
    # ƒoƒgƒ‰[ƒAƒjƒ‚̃f[ƒ^Žæ“¾
    @anime_type = @battler.anime_type
    # bitmap ‚ðƒLƒƒƒbƒVƒ…‰»
    path = @anime_type[0].to_s + "#" + @battler.pattern.to_s
    if not @bitmaps.include?(path) or @bitmaps[path].disposed?
      # ƒtƒ@ƒCƒ‹–¼‚©F‘Š‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
       change = (@battler.character_name != @battler_name or @battler.character_hue != @battler_hue)
      if change
        # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
        @battler_name = @battler.character_name
        @battler_hue = @battler.character_hue
        @bitmap = RPG::Cache.character(@battler_name, @battler_hue)
        @width = @bitmap.width / 4
        @height = @bitmap.height / 4
        self.ox = @width / 2
        self.oy = @height / 2
        @battler.height = @height
        @flag = true
        # 퓬•s”\‚Ü‚½‚͉B‚êó‘Ô‚È‚ç•s“§–¾“x‚ð 0 ‚É‚·‚é
        if @battler.dead? or @battler.hidden
          self.opacity = 0
        end
      end
      if (@anime_type[0] != @battler_condition or
         @battler.pattern != @battler_pattern or flag)
        # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
        @battler_condition = @anime_type[0]
        @battler_pattern = @battler.pattern
        @sx = @battler.pattern * @width
        @sy = @anime_type[0] % 4 * @height
        self.bitmap = Bitmap.new(@width,@height)
        self.bitmap.blt(0,0, @bitmap,Rect.new(@sx, @sy, @width, @height))
        @bitmaps[path] = self.bitmap
        flag = false
      end
    end
     self.bitmap = @bitmaps[path]
    # ”òs
    update_fly
    # ƒVƒFƒCƒN
    update_shake
    # ‰ñ“]
    update_turning
    # ”½“]
    update_reverse
    # ˆÚ“®
    update_moving
    # ’ljÁƒAƒjƒ
    update_add_anime
    # ƒGƒtƒFƒNƒgŒø‰Ê‚Ì“K—p
    update_effect
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    flag = RTAB ? true : @battler.damage == nil
    if flag and @battler.state_animation_id != @state_animation_id
      @state_animation_id = @battler.state_animation_id
      loop_animation($data_animations[@state_animation_id])
    end
    # ƒVƒFƒCƒN
    if @battler.shake
      self.start_shake(5, 5, 5)
      @battler.shake = false
    end
    # –¾–Å
    if @battler.blink
      blink_on
    else
      blink_off
    end
    # •s‰ÂŽ‹‚Ìê‡
    unless @battler_visible
      flag = RTAB ? (@battler.damage.size < 2 or @battler.damage_pop.size < 2) :
                    (@battler.damage == nil or @battler.damage_pop)
      # oŒ»
      if not @battler.hidden and not @battler.dead? and flag
        appear
        @battler_visible = true
      end
    end
    if RTAB
    # ƒ_ƒ[ƒW
    for battler in @battler.damage_pop
      if battler[0].class == Array
        if battler[0][1] >= 0
          $scene.skill_se
        else
          $scene.levelup_se
        end
        damage(@battler.damage[battler[0]], false, 2)
      else
        damage(@battler.damage[battler[0]], @battler.critical[battler[0]])
      end
      if @battler.damage_sp.include?(battler[0])
        damage(@battler.damage_sp[battler[0]],
                @battler.critical[battler[0]], 1)
        @battler.damage_sp.delete(battler[0])
      end
      @battler.damage_pop.delete(battler[0])
      @battler.damage.delete(battler[0])
      @battler.critical.delete(battler[0])
    end
    end
    # ‰ÂŽ‹‚Ìê‡
    if @battler_visible
      # “¦‘–
      if @battler.hidden
        $game_system.se_play($data_system.escape_se)
        escape
        @battler_visible = false
      end
      # ”’ƒtƒ‰ƒbƒVƒ…
      if @battler.white_flash
        whiten
        @battler.white_flash = false
      end
      if RTAB
      # ƒAƒjƒ[ƒVƒ‡ƒ“
      if !@battler.animation.empty?
        for animation in @battler.animation.reverse
          if animation[2]
            animation($data_animations[animation[0]], animation[1], true)
          else
            animation($data_animations[animation[0]], animation[1])
          end
          @battler.animation.delete(animation)
        end
      end
      else
      # ƒAƒjƒ[ƒVƒ‡ƒ“
      if @battler.animation_id != 0
        animation = $data_animations[@battler.animation_id]
        animation(animation, @battler.animation_hit)
        @battler.animation_id = 0
      end
      end
      # ƒ_ƒ[ƒW
      if !RTAB and @battler.damage_pop
        damage(@battler.damage, @battler.critical)
        @battler.damage = nil
        @battler.critical = false
        @battler.damage_pop = false
      end
      flag = RTAB ? (@battler.damage.empty? and $scene.dead_ok?(@battler)) :
                     @battler.damage == nil
      # ƒRƒ‰ƒvƒX
      if flag and @battler.dead?
        if @battler.is_a?(Game_Actor)
          $game_system.se_play($data_system.actor_collapse_se)
        elsif @battler.is_a?(Game_Enemy)
          $game_system.se_play($data_system.enemy_collapse_se)
        end
        collapse
        @battler_visible = false
      end
    end
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    self.x = @battler.screen_x + @effect_ox
    self.y = @battler.screen_y + @effect_oy
    self.z = @battler.screen_z
    self.zoom_x = @battler.real_zoom
    self.zoom_y = @battler.real_zoom
    # ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
    @battler.wait_count -= 1
    @battler.wait_count2 -= 1
    # ƒAƒjƒ[ƒVƒ‡ƒ“‘Ò‚¿ŽžŠÔŽæ“¾
    @battler.animation_duration = @_animation_duration
    if @battler.is_a?(Game_Actor)
      self.zoom_x *= CHAR_ZOOM
      self.zoom_y *= CHAR_ZOOM
    end
    # ‰“‹——£ƒAƒjƒ
    if @battler.flying_anime != [0,0,false,false] and @flying.nil?
      @flying = Sprite_Flying.new(self.viewport, @battler)
    elsif @battler.flying_anime == [0,0,false,false] and !@flying.nil?
      @flying.dispose
      @flying = nil
    end
    if @flying != nil
      @flying.battler = @battler
      @flying.update
    end
    if @battler.is_a?(Game_Actor)
      # •ŠíƒAƒjƒ
      if @battler.weapon_anime_type1 and @weapon.nil?
        @weapon = Sprite_Weapon.new(self.viewport, @battler)
      elsif !@battler.weapon_anime_type1 and !@weapon.nil?
        @weapon.dispose
        @weapon = nil
      end
      if @weapon != nil
        @weapon.battler = @battler
        @weapon.update
        @weapon.opacity = self.opacity
        @weapon.x = self.x + BLZ_X[@battler.weapon_anime_type3][@battler.pattern]
        @weapon.y = self.y + BLZ_Y[@battler.weapon_anime_type3][@battler.pattern]
        @weapon.angle = BLZ_ANGLE[@battler.weapon_anime_type3][@battler.pattern]
        if self.mirror
          @weapon.angle += @weapon.angle - 180
        end
      end
    end
    # Žc‘œ
    if @battler.shadow
      if Graphics.frame_count % 2 == 0
        shadow = ::Sprite.new(self.viewport)
        shadow.bitmap = self.bitmap.dup
        shadow.x = self.x
        shadow.y = self.y
        shadow.ox = self.ox
        shadow.oy = self.oy
        shadow.mirror = self.mirror
        shadow.angle = self.angle
        shadow.opacity = 160
        shadow.zoom_x = self.zoom_x
        shadow.zoom_y = self.zoom_y
        if @battler.is_a?(Game_Actor)
          shadow.src_rect.set(@sx, @sy, @width, @height)
        else
          shadow.src_rect.set(0, 0, @width, @height)
        end
        @shadow.push([shadow,duration = 10,@battler.true_x + @effect_ox,@battler.true_y + @effect_oy])
      end
    end
    for s in @shadow
      if !s[0].disposed?
        s[0].update
        s[1] -= 1
        if s[1] < 1
          if s[0].bitmap != nil
            s[0].bitmap.dispose
          end
          s[0].dispose
        else
          s[0].x = @battler.screen_x(s[2])
          s[0].y = @battler.screen_y(s[3])
        end
      else
        s = nil
      end
    end
    @shadow.compact!
  end
  #--------------------------------------------------------------------------
  # œ ƒGƒtƒFƒNƒg‚É‚æ‚éÀ•WŒn‚ÌXV
  #--------------------------------------------------------------------------
  def update_effect
    # Šp“x‚ÌC³
    if @_upside_down
      self.angle = (@_turning + 180) % 360
    else
      self.angle = @_turning
    end
    # X À•W‚ÌC³’l
    @effect_ox = @_shake + @_moving[0]
    # Y À•W‚ÌC³’l
    @effect_oy = -@fly + @_moving[1]
    if  @_animation == nil or (RTAB and @_animation.empty?)
      self.effect_clear
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒVƒFƒCƒNXV
  #--------------------------------------------------------------------------
  def update_shake
    if @_shake_duration >= 1 or @_shake != 0
      delta = (@_shake_power * @_shake_speed * @_shake_direction) / 10.0
      if @_shake_duration <= 1 and @_shake * (@_shake + delta) < 0
        @_shake = 0
      else
        @_shake += delta
      end
      if @_shake > @_shake_power * 2
        @_shake_direction = -1
      end
      if @_shake < - @_shake_power * 2
        @_shake_direction = 1
      end
      if @_shake_duration >= 1
        @_shake_duration -= 1
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ”òsXV
  #--------------------------------------------------------------------------
  def update_fly
    if @rand > 0
      @rand -= 1
      return
    end
    if @battler.fly != 0
      if @fly < @battler.fly / 4
        @fly_direction = 1
      elsif @fly > @battler.fly / 2
        @fly_direction = -1
      end
      @fly += 0.5 * @fly_direction
    end
  end
  #--------------------------------------------------------------------------
  # œ ‰ñ“]XV
  #--------------------------------------------------------------------------
  def update_turning
    if @_turning_duration > 0 or @_turning != 0
      @_turning += @_turning_direction * @_turning_speed / 2.0
      # Žc‚è‰ñ“]”‚ðŒ¸‚ç‚·
      if @_turning_direction == -1
        if @_turning_duration > 0 and @_turning < 0
          @_turning_duration -= 1
        end
      elsif @_turning_direction == 1
        if @_turning_duration > 0 and @_turning >= 360
          @_turning_duration -= 1
        end
      end
      # ˆÈ‰º•â³
      while @_turning < 0
        @_turning += 360
      end
      if @_turning_duration <= 0
        @_turning = 0
      end
      @_turning %= 360
    end
  end
  #--------------------------------------------------------------------------
  # œ ¶‰E”½“]XV
  #--------------------------------------------------------------------------
  def update_reverse
    if @last_reverse != (@_reverse or @battler.reverse)
      self.mirror = (@_reverse or @battler.reverse)
      @last_reverse = (@_reverse or @battler.reverse)
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®XV
  #--------------------------------------------------------------------------
  def update_moving
    @move_distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
                     (@_move_coordinates[3] - @_move_coordinates[1]).abs
    if @move_distance > 0
      return if @_moving[0] == @_move_coordinates[0] and @_moving[1] == @_move_coordinates[1]
      array = @_move_coordinates
      x = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
      y = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
      @_moving = [x, y]
      if @_move_quick_return and @_move_duration == 0
        @_move_coordinates = [0,0,array[0],array[1]]
        @_move_duration = @move_distance
      end
      @_move_duration -= @_move_speed
      @_move_duration = [@_move_duration, 0].max
    end
  end
  #--------------------------------------------------------------------------
  # œ ’ljÁƒAƒjƒXV (RTABŒÀ’è‹@”\)
  #--------------------------------------------------------------------------
  def update_add_anime
    if RTAB
    # ƒAƒjƒ[ƒVƒ‡ƒ“
    if @_add_anime_id != 0
      animation = $data_animations[@_add_anime_id]
      animation(animation, true)
      @_add_anime_id = 0
    end
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒGƒtƒFƒNƒg‰Šú‰»
  #--------------------------------------------------------------------------
  def effect_clear
    @_effect_ox = 0
    @_effect_oy = 0
    @_shake_power = 0
    @_shake_speed = 0
    @_shake_duration = 0
    @_shake_direction = 1
    @_shake = 0
    @_upside_down = false
    @_reverse = false
    @_turning_direction = 1
    @_turning_speed = 0
    @_turning_duration = 0
    @_turning = 0
    @_move_quick_return = true
    @_move_speed = 0
    @_move_coordinates = [0,0,0,0]
    @_move_jump = false
    @_move_duration = 0
    @_moving = [0,0]
    @_add_anime_id = 0
  end
  #--------------------------------------------------------------------------
  # œ ƒVƒFƒCƒN‚ÌŠJŽn
  #     power    : ‹­‚³
  #     speed    : ‘¬‚³
  #     duration : ŽžŠÔ
  #--------------------------------------------------------------------------
  def start_shake(power, speed, duration)
    @_shake_power = power
    @_shake_speed = speed
    @_shake_duration = duration
  end
  #--------------------------------------------------------------------------
  # œ ㉺”½“]‚ðŠJŽn
  #--------------------------------------------------------------------------
  def start_upside_down
    @_upside_down = @_upside_down ? false : true
  end
  #--------------------------------------------------------------------------
  # œ ¶‰E”½“]‚ðŠJŽn
  #--------------------------------------------------------------------------
  def start_reverse
    @_reverse = @_reverse ? false : true
  end
  #--------------------------------------------------------------------------
  # œ ‰ñ“]‚ðŠJŽn
  #     direction: •ûŒü
  #     speed    : ‘¬‚³
  #     duration : ŽžŠÔ
  #--------------------------------------------------------------------------
  def start_turning(direction, speed, duration)
    @_turning_direction = direction
    @_turning_speed = speed
    @_turning_duration = duration
    @_turning = @_turning_direction == 1 ? 0 : 360
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®‚ðŠJŽn
  #     quick_return : –ß‚é‚©‚Ç‚¤‚©
  #     speed        : ‘¬‚³
  #     x            : X À•W
  #     y            : Y À•W
  #--------------------------------------------------------------------------
  def start_moving(quick_return, speed, x, y)
    @_move_quick_return = quick_return == 0 ? false : true
    @_move_speed = speed
    @_move_coordinates = [x,y,@_move_coordinates[0],@_move_coordinates[1]]
    distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
               (@_move_coordinates[3] - @_move_coordinates[1]).abs
    @_move_duration = distance
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒ’ljÁ‚ðŠJŽn
  #     id           : ID
  #     hit          : –½’†ƒtƒ‰ƒbƒO
  #--------------------------------------------------------------------------
  def start_add_anime(id)
    @_add_anime_id = id
  end
  #--------------------------------------------------------------------------
  # œ ŠeŽíƒGƒtƒFƒNƒg‚ÌŠJŽn”»’è
  #--------------------------------------------------------------------------
  if !method_defined?("side_view_animation_process_timing")
    alias side_view_animation_process_timing animation_process_timing
  end
  def animation_process_timing(timing, hit)
    side_view_animation_process_timing(timing, hit)
    if (timing.condition == 0) or
       (timing.condition == 1 and hit == true) or
       (timing.condition == 2 and hit == false)
      if timing.se.name =~ SHAKE_FILE
        names = timing.se.name.split(/#/)
        power    = names[1].nil? ? SHAKE_POWER    : names[1].to_i
        speed    = names[2].nil? ? SHAKE_SPEED    : names[2].to_i
        duration = names[3].nil? ? SHAKE_DURATION : names[3].to_i
        # ƒVƒFƒCƒN‚ðŠJŽn
        self.start_shake(power, speed, duration)
      end
      if timing.se.name == UPSIDE_DOWN_FILE
        # ㉺”½“]‚ðŠJŽn
        self.start_upside_down
      end
      if timing.se.name == REVERSE_FILE
        # ¶‰E”½“]‚ðŠJŽn
        self.start_reverse
      end
      if timing.se.name =~ TURNING_FILE
        names = timing.se.name.split(/#/)
        direction = names[1].nil? ? TURNING_DIRECTION : names[1].to_i
        speed     = names[2].nil? ? TURNING_SPEED     : names[2].to_i
        duration  = names[3].nil? ? TURNING_DURATION  : names[3].to_i
        # ‰ñ“]‚ðŠJŽn
        self.start_turning(direction, speed, duration)
      end
      if timing.se.name =~ MOVE_FILE
        names = timing.se.name.split(/#/)
        quick_return= names[1].nil? ? MOVE_RETURN      : names[1].to_i
        speed       = names[2].nil? ? MOVE_SPEED       : names[2].to_i
        x           = names[3].nil? ? MOVE_COORDINATES[0] : names[3].to_i
        y           = names[3].nil? ? MOVE_COORDINATES[1] : names[4].to_i
        # ˆÚ“®‚ðŠJŽn
        self.start_moving(quick_return, speed, x, y)
      end
      if timing.se.name =~ ADD_ANIME_FILE
        names = timing.se.name.split(/#/)
        id = names[1].nil? ? ADD_ANIME_ID      : names[1].to_i
        # ƒAƒjƒ’ljÁ‚ðŠJŽn
        self.start_add_anime(id)
      end
    end
  end

end
#==============================================================================
# ¡ Sprite_Weapon
#------------------------------------------------------------------------------
# @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
# ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
#==============================================================================

class Sprite_Weapon < ::Sprite
  include Side_view
  #--------------------------------------------------------------------------
  # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
  #--------------------------------------------------------------------------
  attr_accessor :battler                  # ƒoƒgƒ‰[
  attr_reader   :cw                       # ƒOƒ‰ƒtƒBƒbƒN‚Ì•
  attr_reader   :ch                       # ƒOƒ‰ƒtƒBƒbƒN‚Ì‚‚³
  #--------------------------------------------------------------------------
  # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
  #     viewport : ƒrƒ…[ƒ|[ƒg
  #     battler  : ƒoƒgƒ‰[ (Game_Battler)
  #--------------------------------------------------------------------------
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
  end
  #--------------------------------------------------------------------------
  # œ ‰ð•ú
  #--------------------------------------------------------------------------
  def dispose
    if self.bitmap != nil
      self.bitmap.dispose
    end
    super
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil or !@battler.is_a?(Game_Actor)
      self.bitmap = nil
      return
    end
    # ƒEƒGƒ|ƒ“ƒAƒjƒ‚̃f[ƒ^Žæ“¾
    @weapon_anime_type = @battler.weapon_anime_type
    # ݒ肪u”ñ•\Ž¦v‚Ìê‡
    if !@weapon_anime_type[1] or @weapon_anime_type[0].nil?
      self.visible = false
      return
    else
      self.visible = true
    end
    # ƒtƒ@ƒCƒ‹–¼‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @weapon_anime_type[0] != @weapon_name
      @weapon_name = @weapon_anime_type[0]
      # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
      self.bitmap = RPG::Cache.icon(@weapon_name)
      @width = bitmap.width
      @height = bitmap.height
      @flag = true
    end
    # Œ»ÝƒAƒjƒƒpƒ^[ƒ“‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @pattern != @battler.pattern or @flag or @condition != @battler.condition
      @pattern = @battler.pattern
      @condition = @battler.condition
      self.ox = @width
      self.oy = @height
      self.z = battler.screen_z
      self.zoom_x = @battler.real_zoom * CHAR_ZOOM
      self.zoom_y = @battler.real_zoom * CHAR_ZOOM
      self.src_rect.set(0, 0, @width, @height)
      self.opacity = 255
      # ƒoƒgƒ‰[‚æ‚èŽè‘O‚É•\Ž¦
      if @weapon_anime_type[2]
        self.z += 10
      # ƒoƒgƒ‰[‚æ‚艜‚É•\Ž¦
      else
        self.z -= 10
      end
      @flag = false
    end
  end
end

#==============================================================================
# ¡ Sprite_Flying
#------------------------------------------------------------------------------
# @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
# ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
#==============================================================================

class Sprite_Flying < RPG::Sprite
  include Side_view
  LATE_COUNT = 20
  #--------------------------------------------------------------------------
  # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
  #--------------------------------------------------------------------------
  attr_accessor :battler                  # ƒoƒgƒ‰[
  #--------------------------------------------------------------------------
  # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
  #     viewport : ƒrƒ…[ƒ|[ƒg
  #     battler  : ƒoƒgƒ‰[ (Game_Battler)
  #--------------------------------------------------------------------------
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @later = LATE_COUNT
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil
      self.bitmap = nil
      loop_animation(nil)
      return
    end
    # ‰“‹——£ƒAƒjƒ
    flying_animation = @battler.flying_animation
    flying_start = flying_animation[0]
    flying_end   = flying_animation[1]
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @anime_id != @battler.flying_anime[0]
      @anime_id = @battler.flying_anime[0]
      @animation = $data_animations[@anime_id]
    end
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ŠJŽn
    if flying_start
      animation(@animation,true)
    elsif flying_end
      # Á‹Ž‚ð’x‚点‚Ä‚Ý‚½‚è‚·‚é
      @later -= 1
      if @later < 0
        animation(nil, true)
        @later = LATE_COUNT
      end
    end
    self.x = @battler.flying_x
    self.y = @battler.flying_y
    self.z = @battler.screen_z + 1000
  end
end
module RPG
  class Skill
    #--------------------------------------------------------------------------
    # œ –‚–@‚©‚Ç‚¤‚©‚Ì”»’f
    #--------------------------------------------------------------------------
    def magic?
      if @atk_f == 0
        return true
      else
        return false
      end
    end
  end
end

# ƒAƒ[ƒJ[ƒ\ƒ‹‚̈ʒuC³

class Arrow_Actor < Arrow_Base
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  alias side_view_update update
  def update
    side_view_update
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    if self.actor != nil && (self.x != self.actor.screen_x + ARROW_OX or self.y != self.actor.screen_y + ARROW_OY)
      self.x = self.actor.screen_x + ARROW_OX
      self.y = self.actor.screen_y + ARROW_OY
    end
  end
end
class Arrow_Enemy < Arrow_Base
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  alias side_view_update update
  def update
    side_view_update
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    if self.enemy != nil && (self.x != self.enemy.screen_x + ARROW_OX or self.y != self.enemy.screen_y + ARROW_OY)
      self.x = self.enemy.screen_x + ARROW_OX
      self.y = self.enemy.screen_y + ARROW_OY
    end
  end
end