====== Sistema de Batalla de RaiseField ======
===== Ficha técnica =====
  * **Nombre original:** Desconocido
  * **Nombre del autor:** RaiseField
  * **Utilidad:** Sistema de batalla lateral
  * **Dependencia de otros scripts:** No
  * **Incompatibilidades:** Desconocidas


===== Instalación =====
Crea un nuevo script encima de "Main" y pega en su interior el siguiente código:

<code ruby>
#--------------------------------------------------------------------------
# ™ƒTƒCƒhƒrƒ…[ ŠÈˆÕ”Š
#
#    (C) copyright by RaiseField     Date 2006/09/23    Ver 1.03
#--------------------------------------------------------------------------
#  ƒTƒCƒhƒrƒ…[í“¬ƒXƒNƒŠƒvƒg•àsƒOƒ‰ƒtƒBƒbƒN”Š      ™Special Thanks by á
#--------------------------------------------------------------------------

#--------------------------------------------------------------------------
#  ƒOƒ‰ƒtƒBƒbƒNƒtƒ@ƒCƒ‹‚Ì‹KŠi
#--------------------------------------------------------------------------
#  ƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN
#  
#  @•àsƒOƒ‰ƒtƒBƒbƒN‚ð‚»‚Ì‚Ü‚ÜŽg‚¢‚Ü‚·B
#  @ 
#  •ŠíƒOƒ‰ƒtƒBƒbƒN
#  
#  @•Ší‚̃AƒCƒRƒâ€œƒOƒ‰ƒtƒBƒbƒN‚ð‚»‚Ì‚Ü‚ÜŽg‚¢‚Ü‚·B      
#      

  
module Side_view
  #--------------------------------------------------------------------------
  # œ RTAB•¹—pƒtƒ‰ƒbƒO@™Ž©â€œ®â€FŽ¯
  #    Scene_Battle ‚É ƒƒ\ƒbƒh synthe? ‚ª‚ ‚é‚©‚Ç‚¤‚©‚Å”FŽ¯
  #    Ž©â€œ®â€FŽ¯‚µ‚½‚­‚È‚¢ê‡‚͏‘‚«Š·‚¦‚Ä‚­‚¾‚³‚¢B
  #--------------------------------------------------------------------------
  if Scene_Battle.method_defined?("synthe?")
    RTAB = true
  else
    RTAB = false
  end
  #--------------------------------------------------------------------------
  # œ RTAB‚̃Jƒƒ‰ƒ[ƒN‚ðŽg‚¤ê‡‚Ì•`‰æˆÊ’u Œë·C³ ™Ž©â€œ®â€FŽ¯
  #    Ž©â€œ®â€FŽ¯‚µ‚½‚­‚È‚¢ê‡‚͏‘‚«Š·‚¦‚Ä‚­‚¾‚³‚¢B
  #--------------------------------------------------------------------------
  def camera_correctness
    return false if !RTAB
    begin 
      return $scene.drive
    rescue
      return false
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒp[ƒeƒB‚̍őålâ€ i‚ ‚­‚Ü‚Å‚àƒXƒvƒ‰ƒCƒg‚𑝂₷‚¾‚¯‚Ì‚à‚́j
  #--------------------------------------------------------------------------
  Party_max = 4
  #--------------------------------------------------------------------------
  # œ ƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN‚ÌŠg‘å—¦(ƒAƒNƒ^[ê—pj
  #--------------------------------------------------------------------------
  CHAR_ZOOM = 1.0
  #--------------------------------------------------------------------------
  # œ ƒAƒ[ƒJ[ƒ\ƒ‹ˆÊ’u•â³
  #--------------------------------------------------------------------------
  ARROW_OX = -64
  ARROW_OY = 64
  #--------------------------------------------------------------------------
  # œ ”òs‚Æ‚µ‚Ĉµ‚¤ƒXƒe[ƒg–¼â€z—ñ
  #--------------------------------------------------------------------------
  FLY_STATES = ["”òs"]
  #--------------------------------------------------------------------------
  # œ í“¬‰æ–ʃp[ƒeƒB‚̈ʒu
  #--------------------------------------------------------------------------
  PARTY_X = 480     # ƒp[ƒeƒB‚Ì X ˆÊ’u
  PARTY_Y = 120     # ƒp[ƒeƒB‚Ì Y ˆÊ’u
  FORMATION_X = 32  # ŠeƒAƒNƒ^[“¯Žm‚ÌŠÔŠu X
  FORMATION_Y = 48  # ŠeƒAƒNƒ^[“¯Žm‚ÌŠÔŠu 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,ƒ‹[ƒv‚·‚é‚©,ƒAƒjƒƒXƒs[ƒh,•Ší•\Ž¦‚·‚é‚©,ƒAƒjƒ‚³‚¹‚È‚¢,•ŠíƒOƒ‰‰EŽèor¶Žè]
    NORMAL            => [1,true , 0,false, true ,""    ], # ’ʏí‘Ò‹@
    WALK_R            => [2,true , 6,false, false,""    ], # ‰EˆÚ“®
    WALK_L            => [1,true , 6,false, false,""    ], # ¶ˆÚ“®
    ATTACK_R          => [1,false, 6,true , false,"‰EŽè"], # ‰EŽèUŒ‚
    ATTACK_L          => [1,false, 6,true , false,"¶Žè"], # ¶ŽèUŒ‚
    MAGIC             => [1,false, 6,false, false,""    ], # ‰EŽèUŒ‚
    ITEM              => [1,false, 6,false, false,""    ], # ¶ŽèUŒ‚
    }
    
  # ƒfƒtƒHƒ‹ƒg’l‚ÌÝ’è  
  ANIME.default = [1,false,12,false,"",""]
  
  # ƒAƒNƒVƒ‡ƒâ€œÝ’è‚ÌŠÖ˜A•t‚¯
  ACTION_LIB = { 
    "ˆÚ“®"                 => "moving_setup",
    "ƒAƒNƒ^[ƒAƒjƒŽÀs"   => "action",
    "‰â€œ‹——£ƒAƒjƒ"         => "flying",
    "ƒAƒNƒ^[ƒAƒjƒ•ÏX"   => "change",
    "s“®ƒAƒjƒ"           => "animation1",
    "‘ΏۃAƒjƒ"           => "animation2",
    "ƒEƒGƒCƒg"             => "wait",
    "¶‰E”½â€œ]"             => "reverse",
    "‘M‚«ƒAƒjƒ"           => "flash",
    "Žc‘œ•\Ž¦"             => "shadow_on",
    "Žc‘œÁ‹Ž"             => "shadow_off",
    "ƒAƒNƒ^[ƒAƒjƒŒÅ’è"   => "freeze",
    "ƒAƒjƒŒÅ’è‰ðœ"       => "freeze_lifting",
    "ƒAƒjƒ[ƒVƒ‡ƒâ€œ‚Ì•\Ž¦" => "animation_start",
    "SE‚̉‰‘t"             => "play_se",
  }
  ACTION_LIB.default = "finish"

  # ƒAƒNƒVƒ‡ƒâ€œÝ’è‚Ì‚Æ‚«‚É ‰EŽèUŒ‚ or ¶ŽèUŒ‚ ‚ð”»•Ê‚·‚éANIME
  # "ƒAƒNƒ^[ƒAƒjƒ•ÏX#ATTACK"‚Æ‚µ‚½‚Æ‚«‚ÉATTACK_R‚Ü‚½‚ÍATTACK_L‚ð”»•Ê‚·‚é
  DUAL_WEAPONS_ANIME = [ATTACK]
  
  #ƒoƒgƒ‰[ƒAƒjƒ[ƒVƒ‡ƒâ€œƒpƒ^[ƒâ€œâ€(‚±‚±‚ðŠÔˆá‚¦‚é‚Ɛ³í‚ɃAƒCƒRƒâ€œ‚ªâ€œ®‚«‚Ü‚¹‚ñ)
  ANIME_PATARN = 3
  #•Ší•\Ž¦XÀ•W
  BLZ_X = {
  # X À•W‚̐ݒè@•ŠíƒAƒjƒ => [1, 2, 3] © ANIME_PATARN‚̐”‚ƍ‡‚킹‚é
  0=>[0,0,0,0],   # ƒAƒjƒ‚È‚µ
  1=>[2,2,2,2],   # U‚艺‚낵
  2=>[15,10,0,0], # “˂«
  3=>[2,2,2,2],   # U‚èã‚°
  4=>[0,0,3,3],   # ‹|Ae
  5=>[0,0,0,0],   # ’ljÁ—p
  6=>[0,0,0,0],   # ’ljÁ—p
  7=>[0,0,0,0],   # ’ljÁ—p
  8=>[0,0,0,0],   # ’ljÁ—p
  }
  #•Ší•\Ž¦YÀ•W
  BLZ_Y = {
  # Y À•W‚̐ݒè@•ŠíƒAƒjƒ => [1, 2, 3] © ANIME_PATARN‚̐”‚ƍ‡‚킹‚é
  0=>[0,0,0,0], # ƒAƒjƒ‚È‚µ
  1=>[6,6,6,6], # U‚艺‚낵
  2=>[6,6,6,6], # “˂«
  3=>[6,6,6,6], # U‚èã‚°
  4=>[8,8,8,8], # ‹|Ae
  5=>[0,0,0,0], # ’ljÁ—p
  6=>[0,0,0,0], # ’ljÁ—p
  7=>[0,0,0,0], # ’ljÁ—p
  8=>[0,0,0,0], # ’ljÁ—p
  }
  #•Ší•\Ž¦Šp“x
  BLZ_ANGLE = {
  # Y À•W‚̐ݒè@•ŠíƒAƒjƒ => [1, 2, 3] © ANIME_PATARN‚̐”‚ƍ‡‚킹‚é
  # •Ê‚É Ž® ‚ðŽg‚í‚È‚­‚Ä’èâ€‚Å‚à‚æ‚¢‚ªŽg‚Á‚½‚Ù‚¤‚ª‚í‚©‚è‚â‚·‚¢‚©‚àH
  0=>[0,0,0,0],                    # ƒAƒjƒ‚È‚µ
  1=>[75-45*3,75-45*2,75-45*1,75-45*1],    # U‚艺‚낵
  2=>[45,45,45,45],                   # “˂«
  3=>[100-45*1,100-45*2,100-45*3,00-45*4], # U‚èã‚°
  4=>[45,45,45,45],                # ‹|Ae
  5=>[0,0,0,0], # ’ljÁ—p
  6=>[0,0,0,0], # ’ljÁ—p
  7=>[0,0,0,0], # ’ljÁ—p
  8=>[0,0,0,0], # ’ljÁ—p
  }
  
  #--------------------------------------------------------------------------
  # œ ƒVƒFƒCƒN‚̐ݒè
  #--------------------------------------------------------------------------
  SHAKE_FILE = "ƒVƒFƒCƒN"  # ƒtƒ@ƒCƒ‹–¼
  SHAKE_POWER = 5          # ‹­‚³
  SHAKE_SPEED = 5          # ‘¬‚³
  SHAKE_DURATION = 5      # ŽžŠÔ
  #--------------------------------------------------------------------------
  # œ ã‰ºâ€½â€œ]‚̐ݒè
  #--------------------------------------------------------------------------
  UPSIDE_DOWN_FILE = "ã‰ºâ€½â€œ]" # ƒtƒ@ƒCƒ‹–¼
  #--------------------------------------------------------------------------
  # œ ¶‰E”½â€œ]‚̐ݒè
  #--------------------------------------------------------------------------
  REVERSE_FILE = "¶‰E”½â€œ]" # ƒtƒ@ƒCƒ‹–¼
  #--------------------------------------------------------------------------
  # œ ‰ñ“]‚̐ݒè
  #--------------------------------------------------------------------------
  TURNING_FILE = "‰ñ“]" # ƒtƒ@ƒCƒ‹–¼
  TURNING_DIRECTION = 1 # •ûŒüi1.”½ŽžŒv‰ñ‚è,-1.ŽžŒv‰ñ‚è)
  TURNING_SPEED = 40    # ‘¬‚³
  TURNING_DURATION = 1  # ‰ñ“]â€
  #--------------------------------------------------------------------------
  # œ ˆÚ“®‚̐ݒè
  #--------------------------------------------------------------------------
  MOVE_FILE = "ˆÚ“®"             # ƒtƒ@ƒCƒ‹–¼
  MOVE_RETURN = 1                # Œ³‚̈ʒu‚É–ß‚é‚©H
  MOVE_SPEED = 32                # ‘¬‚³
  MOVE_COORDINATES = [0,-640]    # Œ³‚̈ʒu‚©‚ç‚Ì‘Š‘΍À•W
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒ’ljÁ‚̐ݒè
  #--------------------------------------------------------------------------
  ADD_ANIME_FILE = "ƒAƒjƒ’ljÁ"  # ƒtƒ@ƒCƒ‹–¼
  ADD_ANIME_ID = 0               # ƒAƒjƒ[ƒVƒ‡ƒâ€œID 
  #--------------------------------------------------------------------------
  # œ ƒfƒtƒHƒ‹ƒg‚ÆRTAB‚̃f[ƒ^•ÏŠ·
  #--------------------------------------------------------------------------
  def convert_battler
    return RTAB ? @active_actor : @active_battler
  end
  #--------------------------------------------------------------------------
  # œ ƒfƒtƒHƒ‹ƒg‚ÆRTAB‚̃f[ƒ^•ÏŠ·2
  #--------------------------------------------------------------------------
  def convert_battler2(*arg)
    return RTAB ? arg[0] : @active_battler
  end
end
</code>
<code ruby>
#--------------------------------------------------------------------------
# œ ƒAƒNƒVƒ‡ƒâ€œÝ’è
#--------------------------------------------------------------------------
module BattleActions
  
  # ‰º‚Ì‚à‚Ì‚Í‚ ‚­‚Ü‚Å‚àˆê—á‚È‚Ì‚Å
  # “Ǝ©‚ɍì‚Á‚Ä‚­‚¾‚³‚¢B

  Actions = {

  "’ʏíUŒ‚" => [
  
  "‘M‚«ƒAƒjƒ",
  "s“®ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#target,32,0,64,0",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#NORMAL",
  "ƒEƒGƒCƒg#5",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#ATTACK",
  "‰â€œ‹——£ƒAƒjƒ",
  "‘ΏۃAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "SE‚̉‰‘t#016-Jump02,80,100",
  "ˆÚ“®#self,0,0,48,5",
  "I—¹"
  ],
  
  "ƒGƒlƒ~[UŒ‚" => [
  
  "‘M‚«ƒAƒjƒ",
  "s“®ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,-36,0,12,0",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#NORMAL",
  "ƒEƒGƒCƒg#5",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#ATTACK",
  "‰â€œ‹——£ƒAƒjƒ",
  "‘ΏۃAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,0,0,12,0",
  "I—¹"
  ],
  
  
  "p”­â€œ®" => [
  
  "‘M‚«ƒAƒjƒ",
  "s“®ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,-32,0,4,0",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#MAGIC",
  "ƒEƒGƒCƒg#15",
  "‰â€œ‹——£ƒAƒjƒ",
  "‘ΏۃAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,0,0,4,2",
  "I—¹"
  ],

  "ƒAƒCƒeƒ€Žg—p" => [
  
  "‘M‚«ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,-32,0,4,0",
  "s“®ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#ITEM",
  "ƒEƒGƒCƒg#15",
  "‰â€œ‹——£ƒAƒjƒ",
  "‘ΏۃAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,0,0,4,2",
  "I—¹"
  ],
  
  "•¥‚¢â€²‚¯" => [
  
  "‘M‚«ƒAƒjƒ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#target_near,50,0,48,6",  
  "¶‰E”½â€œ]",
  "ƒAƒNƒ^[ƒAƒjƒŒÅ’è#ATTACK#3",
  "s“®ƒAƒjƒ",
  "SE‚̉‰‘t#135-Light01,100,100",
  "ƒAƒjƒ[ƒVƒ‡ƒâ€œ‚Ì•\Ž¦#self,42",
  "ƒEƒGƒCƒg#15",
  "¶‰E”½â€œ]",
  "Žc‘œ•\Ž¦",
  "ˆÚ“®#target_far,-50,0,48,0",
  "‘ΏۃAƒjƒ",
  "Žc‘œÁ‹Ž",
  "ƒAƒjƒŒÅ’è‰ðœ",
  "ƒAƒNƒ^[ƒAƒjƒ•ÏX#WALK_L",
  "ˆÚ“®#self,0,0,48,1,0",
  "I—¹"
  ],
  } # ‚±‚±‚ŏI‚í‚è@Á‚³‚È‚¢‚Å‚­‚¾‚³‚¢

end
  
module RPG
  class Weapon
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒâ€œÝ’è
    #--------------------------------------------------------------------------
    def battle_actions
      case @id
      when 1 # ƒuƒƒâ€œƒYƒ\[ƒh
        return BattleActions::Actions["’ʏíUŒ‚"]
      end 
      return BattleActions::Actions["’ʏíUŒ‚"] # ƒfƒtƒHƒ‹ƒg’l
    end
  end
  class Skill
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒâ€œÝ’è
    #--------------------------------------------------------------------------
    def battle_actions
      if self.magic?
        return BattleActions::Actions["p”­â€œ®"] # ƒfƒtƒHƒ‹ƒg’l
      else
        return BattleActions::Actions["•¥‚¢â€²‚¯"] # ƒfƒtƒHƒ‹ƒg’l
      end
    end
  end
  class Item
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒâ€œÝ’è
    #--------------------------------------------------------------------------
    def battle_actions
      return BattleActions::Actions["ƒAƒCƒeƒ€Žg—p"] # ƒfƒtƒHƒ‹ƒg’l
    end
  end
end
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # œ ƒAƒNƒVƒ‡ƒâ€œÝ’è
  #--------------------------------------------------------------------------
  def battle_actions
    return BattleActions::Actions["ƒGƒlƒ~[UŒ‚"] # ƒfƒtƒHƒ‹ƒg’l
  end
end
module RPG
=begin
  
@™ à–¾

@ƒAƒCƒRƒâ€œ•Ší‚Ì“®‚«•û‚̐ݒè‚Å‚·B
@module Side_view ‚Ì BLZ_X, BLZ_Y, BLZ_ANGLE ‚ªŽQÆ‚³‚ê‚Ü‚·B
@‚ ‚­‚Ü‚Å‚à“®‚«•û‚̐ݒè‚Ȃ̂ʼn摜‚̓AƒCƒRƒâ€œ‚ªŽg‚í‚ê‚Ü‚·B

  œ ƒJƒXƒ^ƒ}ƒCƒY•û–@
  
  ‚PAƒf[ƒ^ƒx[ƒX‚©‚ç‚̐ݒèi‰‹‰ŽÒŒü‚¯j
  
    •ŠíƒAƒjƒ‘®«‚ðì‚èA‚»‚ê‚𕐊í‚ւ‚¯‚Ü‚·B
    @@
    —á@•ŠíƒAƒjƒ1@â€Žš‚Í”¼Šp‚ŁAƒXƒy[ƒX‚ÍŠJ‚¯‚È‚¢
  
  ‚QAƒXƒNƒŠƒvƒg‚©‚ç‚̐ݒè(’†‹‰ŽÒŒü‚¯)
  
    case @id
    when 1,2,3,4
      return 1
    when 5,6,7,8
      return 2
    end
    return 0
    
    ‚̂悤‚É•`‚­‚ÆID•Ê‚ÉŽw’è‰Â”\‚Å‚·B
    
    ‚»‚Ì‘¼‚É‚àAðŒ•ªŠò‚È‚Ç‚ð‚¢‚ê‚Đݒ肵‚Ä‚à—Ç‚¢‚Å‚·B
    —Ⴆ‚΁A‘®«ID50‚ðŽ‚Á‚Ä‚¢‚é‚Æ‚«‚́AƒAƒjƒ‚P‚Æ‚µ‚½‚¢‚È‚ç
    
    if @element_set.include?(50)
      return 1
    end
    
    ‚Æ‚µ‚Ü‚·B
    
    ‚PA‚̃f[ƒ^ƒx[ƒX‚©‚ç‚̐ݒè‚ðŽg‚í‚È‚¢ê‡
    element_name = "•ŠíƒAƒjƒ"
    for i in @element_set
      if $data_system.elements[i] =~ /#{element_name}([+-]?[0-9]+)?(%)?/
        return $1.to_i
      end
    end
    ‚̕”•ª‚͍폜‚µ‚Ä‚à‚©‚Ü‚¢‚Ü‚¹‚ñ
  
    
=end
  class Weapon
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒâ€œ
    #--------------------------------------------------------------------------
    def anime
      # ‘®«Žæ“¾—p
      element_name = "•ŠíƒAƒjƒ"
      for i in @element_set
        if $data_system.elements[i] =~ /#{element_name}([+-]?[0-9]+)?(%)?/
          return $1.to_i
        end
      end
      # ƒJƒXƒ^ƒ}ƒCƒYÝ’è@ID Žw’è
      case @id
      when 1,2,3,4
        return 1
      when 5,6,7,8
        return 2
      end
      return 1 # ƒfƒtƒHƒ‹ƒg’l
    end
  end
end
=begin
#--------------------------------------------------------------------------
# œ ‰â€œ‹——£ƒAƒjƒ[ƒVƒ‡ƒâ€œ
#--------------------------------------------------------------------------
@™ à–¾
  
@  s“®ŽÒ‚©‚ç‘Ώێ҂ɃAƒjƒ‚ð”ò‚΂µ‚Ü‚·B
@  ”ò‚΂·ƒAƒjƒ‚ð@ƒf[ƒ^ƒx[ƒX]ƒAƒjƒ[ƒVƒ‡ƒâ€œ@‚ōì‚è‚Ü‚·B
    [ƒAƒjƒ[ƒVƒ‡ƒâ€œID, ƒXƒs[ƒh, ‰•œ‚·‚é‚©H,’¼ü(false)or‹Èü(true)]@‚ÅŽw’肵‚Ü‚·B


  œ ƒJƒXƒ^ƒ}ƒCƒY•û–@
    
    case @id
    when 17,18,19,20
      return [101,32,false,false]
    when 21,22,23,24
      return [102,32,false,false]
    end
    return 0
    
    ‚̂悤‚É•`‚­‚ÆID•Ê‚ÉŽw’è‰Â”\‚Å‚·B
    
    
  œ ƒAƒjƒ[ƒVƒ‡ƒâ€œID
  
  ”ò‚΂·ƒAƒjƒ[ƒVƒ‡ƒâ€œID‚Å‚·B’Z‚¢ê‡‚ÍŒJ‚è•Ô‚µ‚Å•\Ž¦‚³‚ê‚Ü‚·B
  
    
  œ ƒXƒs[ƒh
  
  ‘å‚«‚¢‚Ù‚¤‚ª‘‚¢i‚O‚¾‚ƃAƒjƒ‚͈Ú“®‚µ‚Ü‚¹‚ñj
  
  1  1ƒtƒŒ[ƒ€‚Å1ƒhƒbƒgi‚ނƍl‚¦‚Ä‚­‚¾‚³‚¢B
  
  œ ‰•œ‚·‚é‚©H
  
  true ‚Æ‚µ‚½ê‡Aƒu[ƒƒ‰ƒâ€œ‚̂悤‚ɃAƒjƒ‚ª–ß‚è‚Ü‚·B
  
  œ ’¼ü(false)or‹Èü(true)
  
  true  = ‘ΏۂɌü‚©‚Á‚ċȐü‚ŁAƒAƒjƒ‚ªâ€ò‚Ñ‚Ü‚·BiC³‚Ì—]’n‚ ‚è‚Å‚·‚ªEEEj
  false = ‘ΏۂɌü‚©‚Á‚Ä’¼ü‚ŁAƒAƒjƒ‚ªâ€ò‚Ñ‚Ü‚·B
    
=end
module RPG
  class Weapon
    #--------------------------------------------------------------------------
    # œ ‰â€œ‹——£ƒAƒjƒ[ƒVƒ‡ƒâ€œ
    #--------------------------------------------------------------------------
    def flying_anime
      # ID Žw’è ‚Ì—á
      #case @id
      #when 34 # ƒu[ƒƒ‰ƒâ€œ‚Á‚Û‚¢‚â‚Â
      #  return [103,32,true,true]
      #when 17,18,19,20
      #  return [101,32,false,false]
      #when 21,22,23,24
      #  return [102,32,false,false]
      #end
      return [0,0,false,false] # ƒfƒtƒHƒ‹ƒg’l
    end
  end
  class Skill
    #--------------------------------------------------------------------------
    # œ ‰â€œ‹——£ƒAƒjƒ[ƒVƒ‡ƒâ€œ
    #--------------------------------------------------------------------------
    def flying_anime
      return [0,0,false,false] # ƒfƒtƒHƒ‹ƒg’l
    end
  end
  class Item
    #--------------------------------------------------------------------------
    # œ ‰â€œ‹——£ƒAƒjƒ[ƒVƒ‡ƒâ€œ
    #--------------------------------------------------------------------------
    def flying_anime
      return [0,0,false,false] # ƒfƒtƒHƒ‹ƒg’l
    end
  end
end

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # œ ‰â€œ‹——£ƒAƒjƒ[ƒVƒ‡ƒâ€œ
  #--------------------------------------------------------------------------
  def flying_anime
    return [0,0,false,false] # ƒfƒtƒHƒ‹ƒg’l
  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ƒâ€œƒgiƒ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ƒŒ[ƒ€XV (ŽŸ‚̃AƒNƒVƒ‡ƒâ€œ‚Ö)
  #--------------------------------------------------------------------------
  def update_next
    @action = @battle_actions.shift
    @step = get_step
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (“®ìŽæ“¾)
  #--------------------------------------------------------------------------
  def update_setup
    # ƒAƒNƒVƒ‡ƒâ€œ‚̎擾
    self.get_actions
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ˆÚ“®Žæ“¾)
  #--------------------------------------------------------------------------
  def update_moving_setup
    # ˆÚ“®ƒAƒNƒVƒ‡ƒâ€œ‚̎擾
    self.get_move_action
    # ˆÚ“®–Ú•W‚̐ݒè
    self.move_setup
    @step = "moving"
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ˆÚ“®)
  #--------------------------------------------------------------------------
  def update_moving
    # ˆÚ“®
    self.move
    self.condition = @battler_condition
    # ˆÚ“®Š®—¹‚µ‚½‚玟‚̃Xƒeƒbƒv‚Ö
    if move_end?
      update_next
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (‰â€œ‹——£ƒ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ƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (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ƒŒ[ƒ€XV (‘ΏۃAƒjƒ)
  #--------------------------------------------------------------------------
  def update_animation2
    @animation2_on = true
    # s“®ƒAƒjƒ‚ÌŒã‚ɍs“®‚ðŠJŽn‚·‚é
    if $scene.phase4_step == 4
      id = RTAB ? @anime2 : $scene.animation2_id
      animation = $data_animations[id]
      frame_max = animation != nil ? animation.frame_max : 0
      @wait_count2 = frame_max * 2
      return
    end
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒEƒGƒCƒg)
  #--------------------------------------------------------------------------
  def update_wait
    @wait_count2 = @action.split(/#/)[1].to_i
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (Žc‘œ•\Ž¦)
  #--------------------------------------------------------------------------
  def update_shadow_on
    @shadow = true
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (Žc‘œÁ‹Ž)
  #--------------------------------------------------------------------------
  def update_shadow_off
    @shadow = false
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (¶‰E”½â€œ])
  #--------------------------------------------------------------------------
  def update_reverse
    @reverse = @reverse ? false : true
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (‘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ƒŒ[ƒ€XV (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ƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ’è‰ðœ)
  #--------------------------------------------------------------------------
  def update_freeze_lifting
    @pattern_freeze = false
    @condition_freeze = false
    update_next
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (“®ì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ƒ‰[‚̏ó‘Ô •ÏXiƒ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ƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    # ƒEƒFƒCƒg’†‚̏ꍇ
    if @wait_count == 0
      # ƒpƒ^[ƒâ€œXV
      self.char_animation
      @wait_count = ANIME[@battler_condition][2]
    end
    # ƒpƒ^[ƒâ€œXV
    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ƒ^[ƒâ€œXV
  #--------------------------------------------------------------------------
  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

</code>
<code ruby>
#==============================================================================
# ¡ 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 == "‰EŽè"
    return weapon_anime2 if type == "¶Žè"
    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 == "¶Žè"
    return false
  end
  # •Ší‚Ì“®ìNoDŽæ“¾
  def weapon_anime_type3(type = @battler_condition)
    type = ANIME[type][5]
    return extend_weapon_anime1 if type == "‰EŽè"
    return extend_weapon_anime2 if type == "¶Žè"
    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Œ‚—pAƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
  #--------------------------------------------------------------------------
  def attack_x(z)
    return (320 - true_x) * z * 0.75
  end
  #--------------------------------------------------------------------------
  # œ UŒ‚—pAƒ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

</code>
<code ruby>
#==============================================================================
# ¡ 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 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

</code>
<code ruby>
#==============================================================================
# ¡ 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ƒŒ[ƒ€XV (ƒƒ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ƒŒ[ƒ€XV (ƒƒ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ƒŒ[ƒ€XV (ƒƒ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 == "Fallo"
            value = target.damage[battler]
          elsif value.is_a?(Numeric) && value > 0
            value = target.damage[battler] == "Fallo" ? 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

</code>
<code ruby>
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ƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚̏ꍇ
    if @battler == nil
      self.bitmap = nil
      @weapon.bitmap = nil
      loop_animation(nil)
      return
    end
    # ƒoƒgƒ‰[XV
    @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‘Š‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
      if @battler.is_a?(Game_Actor) 
        change = (@battler.character_name != @battler_name or @battler.character_hue != @battler_hue)
      elsif @battler.is_a?(Game_Enemy)
        change = (@battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue)
      end
      if change
        # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
        if @battler.is_a?(Game_Actor)
          @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
        else
          @battler_name = @battler.battler_name
          @battler_hue = @battler.battler_hue
          @bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
          @width = @bitmap.width
          @height = @bitmap.height
          @bitmaps["No_Motion"] = @bitmap
        end
        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 @battler.is_a?(Game_Actor) and (@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
    if @battler.is_a?(Game_Actor)
      self.bitmap = @bitmaps[path]
    else
      self.bitmap = @bitmaps["No_Motion"]
    end
    # ”ò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‚̍XV
  #--------------------------------------------------------------------------
  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ƒNXV
  #--------------------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # œ ”òsXV
  #--------------------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # œ ‰ñ“]XV
  #--------------------------------------------------------------------------
  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”½â€œ]XV
  #--------------------------------------------------------------------------
  def update_reverse
    if @last_reverse != (@_reverse or @battler.reverse)
      self.mirror = (@_reverse or @battler.reverse)
      @last_reverse = (@_reverse or @battler.reverse)
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®XV
  #--------------------------------------------------------------------------
  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ƒXV (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

</code>
<code ruby>
#==============================================================================
# ¡ 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ƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  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

</code>
<code ruby>
#==============================================================================
# ¡ 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ƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  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[ƒ\ƒ‹‚̈ʒuC³

class Arrow_Actor < Arrow_Base
  include Side_view
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  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ƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  alias side_view_update update
  def update
    side_view_update
    # ƒXƒvƒ‰ƒCƒg‚̍À•W‚ðÝ’è
    if self.enemy != nil && self.y != self.enemy.screen_y + self.enemy.height/2
      self.x = self.enemy.screen_x
      self.y = self.enemy.screen_y + self.enemy.height/2
    end
  end
end
</code>


===== Utilización =====
Este script convierte el sistema de batalla frontal del RPG Maker en uno lateral. Los gráficos de los héroes serán los mismos charas, y el arma al atacar será el icono del arma que tengan equipada. Los enemigos, en cambio, siguen siendo estáticos.