Herramientas de usuario

Herramientas del sitio


ayuda:rgss:biblioteca:batallaraisefield
no way to compare when less than two revisions

Diferencias

Muestra las diferencias entre dos versiones de la página.


ayuda:rgss:biblioteca:batallaraisefield [2019/09/23 04:01] (actual) – creado - editor externo 127.0.0.1
Línea 1: Línea 1:
 +====== 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 À•W
 +  #                : 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.
  
ayuda/rgss/biblioteca/batallaraisefield.txt · Última modificación: 2019/09/23 04:01 por 127.0.0.1

Excepto donde se indique lo contrario, el contenido de este wiki esta bajo la siguiente licencia: CC0 1.0 Universal
CC0 1.0 Universal Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki