Pls need help

i really need help combining a sideview script and an atb script. wen i battle it comes up as an error. i appreciate for the help and i'm such a newbie at this. if this is in the wrong spot i'll delete after i get a reply. thankyou very much

Spoiler for:

#==============================================================================
# ¦ New_Battle
#------------------------------------------------------------------------------
# Compiled By : MakirouAru
#==============================================================================
# ¥£¥ XRXS_BP 3. Ÿ—˜ŽžHP‰ñ•œ ver.1.01 ¥£¥
# by fukuyama, ÷‰ë Ý“y

# Battle_End_Recovery
#
# í“¬Œã‚̉ñ•œˆ—ƒ‚ƒWƒ…[ƒ‹
#
# Request: stay
# Script: fukuyama
# Test: ƒmƒRƒmŽq
#
# URL: http://www4.big.or.jp/~fukuyama/rgss/Battle_End_Recovery.txt
#

module Battle_End_Recovery

 module Scene_Battle_Module

   # ‰ñ•œ—¦•Ï”‚ÌID
   @@recovery_rate_variable_id = nil

   # ‰ñ•œ—¦‚̎擾
   def battle_end_recovery_rate
     if @@recovery_rate_variable_id.nil?
       @@recovery_rate_variable_id =
         $data_system.variables.index 'í“¬Œã‚̉ñ•œ—¦'
       if @@recovery_rate_variable_id.nil?
         @@recovery_rate_variable_id = false
       end
     end
     return 0 unless @@recovery_rate_variable_id
     return $game_variables[@@recovery_rate_variable_id]
   end

   # í“¬Œã‚̉ñ•œˆ—
   def battle_end_recovery

     # ‰ñ•œ—¦
     recovery_rate = battle_end_recovery_rate
     
     # ‰ñ•œ—¦•Ï”‚ª‚OˆÈŠO‚©‚ƒAƒNƒ^[‚ª¶‘¶‚µ‚Ä‚¢‚éê‡Aí“¬Œã‚̉ñ•œˆ—‚ðs‚¤
     if recovery_rate != 0 and not actor.dead?

       # ƒp[ƒeƒB‚̃AƒNƒ^[–ˆ‚Ƀ‹[ƒv
       $game_party.actors.each do |actor|

         # ‰ñ•œ—ÊŒvŽZ
         recovery_hp = (actor.maxhp / 100.0 * recovery_rate).truncate
         recovery_sp = (actor.maxsp / 100.0 * recovery_rate).truncate

         # ŽÀÛ‚ɉñ•œ
         actor.hp += recovery_hp
         actor.sp += recovery_sp

         # ƒAƒjƒ[ƒVƒ‡ƒ“Ý’è
         actor.damage = - recovery_hp
         actor.damage_pop = true

       end

       # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðXV
       @status_window.refresh

     end
   end

 end # module Scene_Battle_Module
end # module Battle_End_Recovery

#------------------------------
# í“¬ƒV[ƒ“‚̍Ēè‹`
#------------------------------
class Scene_Battle

 # Scene_Battle—pƒ‚ƒWƒ…[ƒ‹‚ðƒCƒ“ƒNƒ‹[ƒh
 include Battle_End_Recovery::Scene_Battle_Module

 # Œ³‚̃tƒF[ƒY‚TŠJŽn‚É•Ê–¼‚ð‚‚¯‚é
 alias battle_end_recovery_original_start_phase5 start_phase5

 # ƒtƒF[ƒY‚TŠJŽn‚ðÄ’è‹`
 def start_phase5

   # í“¬Œã‚̉ñ•œˆ—‚ðŒÄ‚яo‚•
   battle_end_recovery

   # Œ³‚̃tƒF[ƒY‚TŠJŽn‚ðŒÄ‚яo‚•
   battle_end_recovery_original_start_phase5

 end
end

# Battle_End_Recovery
# ¥£¥ XRXS_BP10. LEVEL UP!ƒEƒBƒ“ƒhƒE ¥£¥
# by ÷‰ë Ý“y

$data_system_level_up_se = ""                       # ƒŒƒxƒ‹ƒAƒbƒvSEB""‚Å–³‚µB
$data_system_level_up_me = "Audio/ME/007-Fanfare01" # ƒŒƒxƒ‹ƒAƒbƒvME

#==============================================================================
# ¡ Window_LevelUpWindow
#------------------------------------------------------------------------------
# @ƒoƒgƒ‹I—¹ŽžAƒŒƒxƒ‹ƒAƒbƒv‚µ‚½ê‡‚ɃXƒe[ƒ^ƒX‚ð•\Ž¦‚•‚éƒEƒBƒ“ƒhƒE‚Å‚•B
#==============================================================================
class Window_LevelUpWindow < Window_Base
 #--------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
 #--------------------------------------------------------------------------
 def initialize(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
   super(0, 128, 160, 192)
   self.contents = Bitmap.new(width - 32, height - 32)
   self.visible = false
   refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
 end
 #--------------------------------------------------------------------------
 # œ ƒŠƒtƒŒƒbƒVƒ…
 #--------------------------------------------------------------------------
 def refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
   self.contents.clear
   self.contents.font.color = system_color
   self.contents.font.name = "Arial"
   self.contents.font.size = 14
   self.contents.draw_text( 0,   0, 160, 24, "LEVEL UP!!")
   self.contents.font.size = 18
   self.contents.draw_text( 0,  28, 160, 24, $data_system.words.hp)
   self.contents.draw_text( 0,  50, 160, 24, $data_system.words.sp)
   self.contents.font.size = 14
   self.contents.draw_text( 0,  72,  80, 24, $data_system.words.str)
   self.contents.draw_text( 0,  94,  80, 24, $data_system.words.dex)
   self.contents.draw_text( 0, 116,  80, 24, $data_system.words.agi)
   self.contents.draw_text( 0, 138,  80, 24, $data_system.words.int)
   self.contents.draw_text(92,   0, 128, 24, "¨")
   self.contents.draw_text(76,  28, 128, 24, "=")
   self.contents.draw_text(76,  50, 128, 24, "=")
   self.contents.draw_text(76,  72, 128, 24, "=")
   self.contents.draw_text(76,  94, 128, 24, "=")
   self.contents.draw_text(76, 116, 128, 24, "=")
   self.contents.draw_text(76, 138, 128, 24, "=")
   self.contents.font.color = normal_color
   self.contents.draw_text( 0,   0,  88, 24, last_lv.to_s, 2)
   self.contents.draw_text( 0,  28,  72, 24, "+" + up_hp.to_s, 2)
   self.contents.draw_text( 0,  50,  72, 24, "+" + up_sp.to_s, 2)
   self.contents.draw_text( 0,  72,  72, 24, "+" + up_str.to_s, 2)
   self.contents.draw_text( 0,  94,  72, 24, "+" + up_dex.to_s, 2)
   self.contents.draw_text( 0, 116,  72, 24, "+" + up_agi.to_s, 2)
   self.contents.draw_text( 0, 138,  72, 24, "+" + up_int.to_s, 2)
   self.contents.font.size = 20
   self.contents.draw_text( 0,   0, 128, 24, actor.level.to_s, 2)
   self.contents.draw_text( 0,  26, 128, 24, actor.maxhp.to_s, 2)
   self.contents.draw_text( 0,  48, 128, 24, actor.maxsp.to_s, 2)
   self.contents.draw_text( 0,  70, 128, 24, actor.str.to_s, 2)
   self.contents.draw_text( 0,  92, 128, 24, actor.dex.to_s, 2)
   self.contents.draw_text( 0, 114, 128, 24, actor.agi.to_s, 2)
   self.contents.draw_text( 0, 136, 128, 24, actor.int.to_s, 2)
 end
end
#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
 #--------------------------------------------------------------------------
 # œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
 #--------------------------------------------------------------------------
   attr_accessor :level_up_flags             # LEVEL UP!•\Ž¦
end
#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
 #--------------------------------------------------------------------------
 # œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
 #--------------------------------------------------------------------------
 attr_accessor :exp_gain_ban             # EXPŽæ“¾ˆêŽž‹ÖŽ~
 #--------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
 #--------------------------------------------------------------------------
 alias xrxs_bp10_initialize initialize
 def initialize
   @exp_gain_ban = false
   xrxs_bp10_initialize
 end
 #--------------------------------------------------------------------------
 # œ ƒXƒe[ƒg [EXP ‚ðŠl“¾‚Å‚«‚È‚¢] ”»’è
 #--------------------------------------------------------------------------
 alias xrxs_bp10_cant_get_exp? cant_get_exp?
 def cant_get_exp?
   if @exp_gain_ban == true
     return true
   else
     return xrxs_bp10_cant_get_exp?
   end
 end
end
#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
 #--------------------------------------------------------------------------
 # œ ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
 #--------------------------------------------------------------------------
 alias xrxs_bp10_start_phase5 start_phase5
 def start_phase5
   # EXP Šl“¾‹ÖŽ~
   for i in 0...$game_party.actors.size
     $game_party.actors.exp_gain_ban = true
   end
   xrxs_bp10_start_phase5
   # EXP Šl“¾‹ÖŽ~‚̉ðœ
   for i in 0...$game_party.actors.size
     $game_party.actors.exp_gain_ban = false
   end
   # EXP‚ð‰Šú‰»
   @exp_gained = 0
   for enemy in $game_troop.enemies
     # Šl“¾ EXP‚ð’ljÁ         # ƒGƒlƒ~[‚ª‰B‚êó‘Ô‚Å‚È‚¢ê‡
     @exp_gained += enemy.exp if not enemy.hidden
   end
   # Ý’è
   @phase5_step       = 0
   @exp_gain_actor    = -1
   # ƒŠƒUƒ‹ƒgƒEƒBƒ“ƒhƒE‚ð•\Ž¦
   @result_window.y -= 64
   @result_window.visible = true
   # ƒŒƒxƒ‹ƒAƒbƒv”»’è‚Ö
   phase5_next_levelup
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒY)
 #--------------------------------------------------------------------------
 alias xrxs_bp10_update_phase5 update_phase5
 def update_phase5
   case @phase5_step
   when 1
     update_phase5_step1
   else
     xrxs_bp10_update_phase5
     # ƒŒƒxƒ‹ƒAƒbƒv‚µ‚Ä‚¢‚éê‡‚Í‹¬§ƒoƒgƒ‹I—¹
     battle_end(0) if @levelup_window != nil and @phase5_wait_count <= 0
   end
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒY 1 : ƒŒƒxƒ‹ƒAƒbƒv)
 #--------------------------------------------------------------------------
 def update_phase5_step1
   # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
   if Input.trigger?(Input::C)
     # ƒEƒBƒ“ƒhƒE‚ð•Â‚¶‚ÄŽŸ‚̃AƒNƒ^[‚Ö
     @levelup_window.visible = false if @levelup_window != nil
     @status_window.level_up_flags[@exp_gain_actor] = false
     phase5_next_levelup
   end
 end
 #--------------------------------------------------------------------------
 # œ ŽŸ‚̃AƒNƒ^[‚̃Œƒxƒ‹ƒAƒbƒv•\Ž¦‚Ö
 #--------------------------------------------------------------------------
 def phase5_next_levelup
   begin
     # ŽŸ‚̃AƒNƒ^[‚Ö
     @exp_gain_actor += 1
     # ÅŒã‚̃AƒNƒ^[‚̏ꍇ
     if @exp_gain_actor >= $game_party.actors.size
       # ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
       @phase5_step = 0
       return
     end
     actor = $game_party.actors[@exp_gain_actor]
     if actor.cant_get_exp? == false
       # Œ»Ý‚Ì”\—Í’l‚ð•ÛŽ
       last_level = actor.level
       last_maxhp = actor.maxhp
       last_maxsp = actor.maxsp
       last_str = actor.str
       last_dex = actor.dex
       last_agi = actor.agi
       last_int = actor.int
       # ŒoŒ±’lŽæ“¾‚ÌŒˆ’è“IuŠÔ(“ä
       actor.exp += @exp_gained
       # ”»’è
       if actor.level > last_level
         # ƒŒƒxƒ‹ƒAƒbƒv‚µ‚½ê‡
         @status_window.level_up(@exp_gain_actor)
         if $data_system_level_up_se != ""
           Audio.se_stop
           Audio.se_play($data_system_level_up_se)
         end
         if $data_system_level_up_me != ""
           Audio.me_stop
           Audio.me_play($data_system_level_up_me)
         end
         @levelup_window = Window_LevelUpWindow.new(actor, last_level,
           actor.maxhp - last_maxhp, actor.maxsp - last_maxsp, actor.str - last_str,
           actor.dex - last_dex, actor.agi - last_agi, actor.int - last_int)
         @levelup_window.x = 160 * @exp_gain_actor
         @levelup_window.visible = true
         @phase5_wait_count = 40
         @phase5_step       =  1
         # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
         @status_window.refresh
         return
       end
     end
   end until false
 end
end
# ¥£¥ XRXS_17. ƒXƒŠƒbƒvƒ_ƒ[ƒW–hŒä^Œø‰Ê—ʏڍ׉» ver.1.51 ¥£¥
# by ÷‰ë Ý“y, fukuyama

#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
 #--------------------------------------------------------------------------
 # œ ƒXƒŠƒbƒvƒ_ƒ[ƒW‚ÌŒø‰Ê“K—p
 #--------------------------------------------------------------------------
 alias xrxs_bp7_slip_damage_effect slip_damage_effect
 def slip_damage_effect
   # ”’l‚̏‰Šú‰»
   slip_damage_percent = 0
   slip_damage_plus = 0
   # Œ»Ý•t‰Á‚³‚ê‚Ä‚¢‚éƒXƒe[ƒg‚Ì’†‚©‚çƒXƒŠƒbƒvƒ_ƒ[ƒW—L‚è‚̃‚ƒm‚ð’T‚•
   for i in @states
     if $data_states.slip_damage
       # ‚»‚̃Xƒe[ƒg‚ªŽ‚Á‚Ä‚¢‚éƒXƒŠƒbƒvƒ_ƒ[ƒW‚Ì
       # Lvƒvƒ‰ƒXƒXƒe[ƒg‚Ü‚½‚ÍLvƒ}ƒCƒiƒXƒXƒe[ƒg‚ð”»’èB
       for j in $data_states.plus_state_set
         if $data_states[j] != nil
           if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
             slip_damage_percent += $1.to_i
           elsif $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
             slip_damage_plus += $1.to_i
           end
         end
       end
       for j in $data_states.minus_state_set
         if $data_states[j] != nil
           if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
             slip_damage_percent -= $1.to_i
           elsif $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
             slip_damage_plus -= $1.to_i
           end
         end
       end
     end
   end
   if slip_damage_percent == 0 and slip_damage_plus == 0
     xrxs_bp7_slip_damage_effect
   else
     # –h‹ï‚ªƒXƒŠƒbƒv–hŒä‚ª‚ ‚éê‡‚ð”»’è
     for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
       armor = $data_armors
       next if armor == nil
       for j in armor.guard_state_set
         if $data_states[j] != nil
           if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
             if slip_damage_percent > 0
               slip_damage_percent = [slip_damage_percent - $1.to_i, 0].max
             end
           end
           if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
             if slip_damage_percent > 0
               slip_damage_plus = [slip_damage_plus - $1.to_i, 0].max
             end
           end
         end
       end
     end
     # ƒ_ƒ[ƒW‚ðÝ’è
     self.damage = self.maxhp * slip_damage_percent / 100 + slip_damage_plus
     # •ªŽU
     if self.damage.abs > 0
       amp = [self.damage.abs * 15 / 100, 1].max
       self.damage += rand(amp+1) + rand(amp+1) - amp
     end
     # HP ‚©‚çƒ_ƒ[ƒW‚ðŒ¸ŽZ
     self.hp -= self.damage
     # ƒƒ\ƒbƒhI—¹
     return true
   end
 end
end
# ¥£¥ XRXS_BP 1. CP§“±“ü ver.15 ¥£¥
# by ÷‰ë Ý“y, ˜aŠó, Jack-R

#==============================================================================
# ¡ Scene_Battle_CP
#==============================================================================
class Scene_Battle_CP
 #--------------------------------------------------------------------------
 # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
 #--------------------------------------------------------------------------
 attr_accessor   :stop                   # CP‰ÁŽZƒXƒgƒbƒv
 #----------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‚̏‰Šú‰»
 #----------------------------------------------------------------------------
 def initialize
   @battlers = []
   @cancel = false
   @agi_total = 0
   # ”z—ñ @count_battlers ‚ð‰Šú‰»
   @count_battlers = []
   # ƒGƒlƒ~[‚ð”z—ñ @count_battlers ‚ɒljÁ
   for enemy in $game_troop.enemies
     @count_battlers.push(enemy)
   end
   # ƒAƒNƒ^[‚ð”z—ñ @count_battlers ‚ɒljÁ
   for actor in $game_party.actors
     @count_battlers.push(actor)
   end
   for battler in @count_battlers
     @agi_total += battler.agi
   end
   for battler in @count_battlers
     battler.cp = [[65535 * (rand(15) + 85) / 100 * battler.agi / @agi_total * 4, 0].max, 65535].min
   end
 end
 #----------------------------------------------------------------------------
 # œ CPƒJƒEƒ“ƒg‚ÌŠJŽn
 #----------------------------------------------------------------------------
 def start
   if @cp_thread != nil then
     return
   end
   @cancel = false
   @stop = false
   # ‚±‚±‚©‚çƒXƒŒƒbƒh
   @cp_thread = Thread.new do
     while @cancel != true
       if @stop != true
         self.update # XV
         sleep(0.05)
       end
     end
   end
   # ‚±‚±‚܂ŃXƒŒƒbƒh
 end
 #----------------------------------------------------------------------------
 # œ CPƒJƒEƒ“ƒgƒAƒbƒv
 #----------------------------------------------------------------------------
 def update
   if @count_battlers != nil then
     for battler in @count_battlers
       # s“®o—ˆ‚È‚¯‚ê‚Ζ³Ž‹
       if battler.dead? == true #or battler.movable? == false then
         battler.cp = 0
         next
       end
       # ‚±‚±‚Ì 1.3‚ð•Ï‚¦‚邱‚ƂŁ«ƒXƒs[ƒh‚ð•ÏX‰Â”\B‚½‚¾‚µ¬”“_‚ÍŽg—p‚•‚邱‚ƁB
       battler.cp = [[battler.cp + 1.3 * 4096 * battler.agi / @agi_total, 0].max, 65535].min
     end
   end
 end
 #----------------------------------------------------------------------------
 # œ CPƒJƒEƒ“ƒg‚ÌŠJŽn
 #----------------------------------------------------------------------------
 def stop
   @cancel = true
   if @cp_thread != nil then
     @cp_thread.join
     @cp_thread = nil
   end
 end
end
#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
 attr_accessor :now_guarding             # Œ»Ý–hŒä’†ƒtƒ‰ƒO
 attr_accessor :cp                       # Œ»ÝCP
 attr_accessor :slip_state_update_ban    # ƒXƒŠƒbƒvEƒXƒe[ƒgŽ©“®ˆ—‚Ì‹ÖŽ~
 #--------------------------------------------------------------------------
 # œ ƒRƒ}ƒ“ƒh“ü—͉”\”»’è
 #--------------------------------------------------------------------------
 def inputable?
   return (not @hidden and restriction <= 1 and @cp >=65535)
 end
 #--------------------------------------------------------------------------
 # œ ƒXƒe[ƒg [ƒXƒŠƒbƒvƒ_ƒ[ƒW] ”»’è
 #--------------------------------------------------------------------------
 alias xrxs_bp1_slip_damage? slip_damage?
 def slip_damage?
   return false if @slip_state_update_ban
   return xrxs_bp1_slip_damage?
 end
 #--------------------------------------------------------------------------
 # œ ƒXƒe[ƒgŽ©‘R‰ðœ (ƒ^[ƒ“‚²‚ƂɌĂяo‚µ)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_remove_states_auto remove_states_auto
 def remove_states_auto
   return if @slip_state_update_ban
   xrxs_bp1_remove_states_auto
 end
end
#==============================================================================
# ¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # œ ƒZƒbƒgƒAƒbƒv
 #--------------------------------------------------------------------------
 alias xrxs_bp1_setup setup
 def setup(actor_id)
   xrxs_bp1_setup(actor_id)
   @hate = 100  # init-value is 100
   @cp = 0
   @now_guarding = false
   @slip_state_update_ban = false
 end
end
#==============================================================================
# ¡ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
 #--------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
 #--------------------------------------------------------------------------
 alias xrxs_bp1_initialize initialize
 def initialize(troop_id, member_index)
   xrxs_bp1_initialize(troop_id, member_index)
   @hate = 100  # init-value is 100
   @cp = 0
   @now_guarding = false
   @slip_state_update_ban = false
 end
end
#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
 #--------------------------------------------------------------------------
 # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
 #--------------------------------------------------------------------------
 attr_accessor   :update_cp_only                   # CPƒ[ƒ^[‚݂̂̍XV
 #--------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
 #--------------------------------------------------------------------------
 alias xrxs_bp1_initialize initialize
 def initialize
   @update_cp_only = false
   xrxs_bp1_initialize
 end
 #--------------------------------------------------------------------------
 # œ ƒŠƒtƒŒƒbƒVƒ…
 #--------------------------------------------------------------------------
 alias xrxs_bp1_refresh refresh
 def refresh
   if @update_cp_only == false
     xrxs_bp1_refresh
   end
   for i in 0...$game_party.actors.size
     actor = $game_party.actors
     actor_x = i * 160 + 4
     draw_actor_cp_meter(actor, actor_x, 96, 120, 0)
   end
 end
 #--------------------------------------------------------------------------
 # œ CPƒ[ƒ^[ ‚Ì•`‰æ
 #--------------------------------------------------------------------------
 def draw_actor_cp_meter(actor, x, y, width = 156, type = 0)
   self.contents.font.color = system_color
   self.contents.fill_rect(x-1, y+27, width+2,6, Color.new(0, 0, 0, 255))
   if actor.cp == nil
     actor.cp = 0
   end
   w = width * [actor.cp,65535].min / 65535
   self.contents.fill_rect(x, y+28, w,1, Color.new(255, 255, 128, 255))
   self.contents.fill_rect(x, y+29, w,1, Color.new(255, 255, 0, 255))
   self.contents.fill_rect(x, y+30, w,1, Color.new(192, 192, 0, 255))
   self.contents.fill_rect(x, y+31, w,1, Color.new(128, 128, 0, 255))
 end
end
#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
 # ‚±‚±‚ÉŒø‰Ê‰¹‚ðÝ’è‚•‚é‚ƁAƒAƒNƒ^[ƒRƒ}ƒ“ƒh‚ªƒ|ƒbƒv‚µ‚½‚Æ‚«‚ÉŒø‰Ê‰¹‚ðÄ¶
 $data_system_command_up_se = ""
 #--------------------------------------------------------------------------
 # œ ƒoƒgƒ‹I—¹
 #     result : Œ‹‰Ê (0:Ÿ—˜ 1:”s–k 2:“¦‘–)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_battle_end battle_end
 def battle_end(result)
   # CPƒJƒEƒ“ƒg’âŽ~
   @cp_thread.stop
   xrxs_bp1_battle_end(result)
 end
 #--------------------------------------------------------------------------
 # œ ƒvƒŒƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
 #--------------------------------------------------------------------------
 alias xrxs_bp1_start_phase1 start_phase1
 def start_phase1
   @agi_total = 0
   @cp_thread = Scene_Battle_CP.new
   # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðÄì¬
   s1 = $data_system.words.attack
   s2 = $data_system.words.skill
   s3 = $data_system.words.guard
   s4 = $data_system.words.item
   @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4, "Run"])
   @actor_command_window.y = 128
   @actor_command_window.back_opacity = 160
   @actor_command_window.active = false
   @actor_command_window.visible = false
   @actor_command_window.draw_item(4, $game_temp.battle_can_escape ? @actor_command_window.normal_color : @actor_command_window.disabled_color)
   xrxs_bp1_start_phase1
 end
 #--------------------------------------------------------------------------
 # œ ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
 #--------------------------------------------------------------------------
 alias xrxs_bp1_start_phase2 start_phase2
 def start_phase2
   xrxs_bp1_start_phase2
   @party_command_window.active = false
   @party_command_window.visible = false
   # ŽŸ‚Ö
   start_phase3
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF[ƒY)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_update_phase2 update_phase2
 def update_phase2
   # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
   if Input.trigger?(Input::C)
     # ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
     case @party_command_window.index
     when 0  # í‚¤
       # Œˆ’è SE ‚ð‰‰‘t
       $game_system.se_play($data_system.decision_se)
       @cp_thread.start
       # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
       start_phase3
     end
     return
   end
   xrxs_bp1_update_phase2
 end
 #--------------------------------------------------------------------------
 # œ ŽŸ‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
 #--------------------------------------------------------------------------
 def phase3_next_actor
   # ƒ‹[ƒv
   begin
     # ƒAƒNƒ^[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
     if @active_battler != nil
       @active_battler.blink = false
     end
     # ÅŒã‚̃AƒNƒ^[‚̏ꍇ
     if @actor_index == $game_party.actors.size-1
       # ƒƒCƒ“ƒtƒF[ƒYŠJŽn
       @cp_thread.start
       start_phase4
       return
     end
     # ƒAƒNƒ^[‚̃Cƒ“ƒfƒbƒNƒX‚ði‚ß‚é
     @actor_index += 1
     @active_battler = $game_party.actors[@actor_index]
     @active_battler.blink = true
     if @active_battler.inputable? == false
       @active_battler.current_action.kind = -1
     end
     # ƒAƒNƒ^[‚ªƒRƒ}ƒ“ƒh“ü—Í‚ðŽó‚¯•t‚¯‚È‚¢ó‘Ô‚È‚ç‚à‚¤ˆê“x
   end until @active_battler.inputable?
   @cp_thread.stop
   # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒZƒbƒgƒAƒbƒv
   @active_battler.now_guarding = false
   phase3_setup_command_window
 end
 #--------------------------------------------------------------------------
 # œ ‘O‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
 #--------------------------------------------------------------------------
 def phase3_prior_actor
   # ƒ‹[ƒv
   begin
     # ƒAƒNƒ^[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
     if @active_battler != nil
       @active_battler.blink = false
     end
     # Å‰‚̃AƒNƒ^[‚̏ꍇ
     if @actor_index == 0
       # Å‰‚Ö–ß‚é
       start_phase3
       return
     end
     # ƒAƒNƒ^[‚̃Cƒ“ƒfƒbƒNƒX‚ð–ß‚•
     @actor_index -= 1
     @active_battler = $game_party.actors[@actor_index]
     @active_battler.blink = true
     # ƒAƒNƒ^[‚ªƒRƒ}ƒ“ƒh“ü—Í‚ðŽó‚¯•t‚¯‚È‚¢ó‘Ô‚È‚ç‚à‚¤ˆê“x
   end until @active_battler.inputable?
   @cp_thread.stop
   # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒZƒbƒgƒAƒbƒv
   @active_battler.now_guarding = false
   phase3_setup_command_window
 end
 #--------------------------------------------------------------------------
 # œ ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃ZƒbƒgƒAƒbƒv
 #--------------------------------------------------------------------------
 alias xrxs_bp1_phase3_setup_command_window phase3_setup_command_window
 def phase3_setup_command_window
   # Œø‰Ê‰¹‚̍ж
   Audio.se_play($data_system_command_up_se) if $data_system_command_up_se != ""
   # –ß‚•
   xrxs_bp1_phase3_setup_command_window
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒY : Šî–{ƒRƒ}ƒ“ƒh)
 #--------------------------------------------------------------------------
 alias xrxs_bsp1_update_phase3_basic_command update_phase3_basic_command
 def update_phase3_basic_command
   # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
   if Input.trigger?(Input::C)
     # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
     case @actor_command_window.index
     when 4  # “¦‚°‚é
       if $game_temp.battle_can_escape
         # Œˆ’è SE ‚ð‰‰‘t
         $game_system.se_play($data_system.decision_se)
         # ƒAƒNƒVƒ‡ƒ“‚ðÝ’è
         @active_battler.current_action.kind = 0
         @active_battler.current_action.basic = 4
         # ŽŸ‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
         phase3_next_actor
       else
         # ƒuƒU[ SE ‚ð‰‰‘t
         $game_system.se_play($data_system.buzzer_se)
       end
       return
     end
   end
   xrxs_bsp1_update_phase3_basic_command
 end
 #--------------------------------------------------------------------------
 # œ ƒƒCƒ“ƒtƒF[ƒYŠJŽn
 #--------------------------------------------------------------------------
 alias xrxs_bp1_start_phase4 start_phase4
 def start_phase4
   xrxs_bp1_start_phase4
   # ƒGƒlƒ~[ƒAƒNƒVƒ‡ƒ“ì¬
   for enemy in $game_troop.enemies
     if enemy.cp < 65535
       enemy.current_action.clear
       enemy.current_action.kind = -1 # ƒ^[ƒ“”ò‚΂µB
       next
     end
     enemy.make_action
   end
   # s“®‡˜ì¬
   make_action_orders
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 1 : ƒAƒNƒVƒ‡ƒ“€”õ)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_update_phase4_step1 update_phase4_step1
 def update_phase4_step1
   # ‰Šú‰»
   @phase4_act_continuation = 0
   # Ÿ”s”»’è
   if judge
     @cp_thread.stop
     # Ÿ—˜‚Ü‚½‚Í”s–k‚̏ꍇ : ƒƒ\ƒbƒhI—¹
     return
   end
   # –¢s“®ƒoƒgƒ‰[”z—ñ‚̐擪‚©‚çŽæ“¾
   @active_battler = @action_battlers[0]
   # ƒXƒe[ƒ^ƒXXV‚ðCP‚¾‚¯‚ÉŒÀ’èB
   @status_window.update_cp_only = true
   # ƒXƒe[ƒgXV‚ð‹ÖŽ~B
   @active_battler.slip_state_update_ban = true if @active_battler != nil
   # –ß‚•
   xrxs_bp1_update_phase4_step1
   # ‹ÖŽ~‚ð‰ðœ
   @status_window.update_cp_only = false
   @active_battler.slip_state_update_ban = false if @active_battler != nil
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_update_phase4_step2 update_phase4_step2
 def update_phase4_step2
   # ‹¬§ƒAƒNƒVƒ‡ƒ“‚Å‚È‚¯‚ê‚Î
   unless @active_battler.current_action.forcing
     # CP‚ª‘«‚è‚Ä‚¢‚È‚¢ê‡
     if @phase4_act_continuation == 0 and @active_battler.cp < 65535
       @phase4_step = 6
       return
     end
     # §–ñ‚ª [“G‚ð’ʏíUŒ‚‚•‚é] ‚© [–¡•û‚ð’ʏíUŒ‚‚•‚é] ‚̏ꍇ
     if @active_battler.restriction == 2 or @active_battler.restriction == 3
       # ƒAƒNƒVƒ‡ƒ“‚ɍUŒ‚‚ðÝ’è
       @active_battler.current_action.kind = 0
       @active_battler.current_action.basic = 0
     end
     # §–ñ‚ª [s“®‚Å‚«‚È‚¢] ‚̏ꍇ
     if @active_battler.restriction == 4
       # ƒAƒNƒVƒ‡ƒ“‹¬§‘Ώۂ̃oƒgƒ‰[‚ðƒNƒŠƒA
       $game_temp.forcing_battler = nil
       if @phase4_act_continuation == 0 and @active_battler.cp >= 65535
         # ƒXƒe[ƒgŽ©‘R‰ðœ
         @active_battler.remove_states_auto
         # CPÁ”ï
         @active_battler.cp = [(@active_battler.cp - 65535),0].max
         # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
         @status_window.refresh
       end
       # ƒXƒeƒbƒv 1 ‚Ɉڍs
       @phase4_step = 1
       return
     end
   end
   # ƒAƒNƒVƒ‡ƒ“‚ÌŽí•Ê‚Å•ªŠò
   case @active_battler.current_action.kind
   when 0
     # UŒ‚¥–hŒäE“¦‚°‚éE‰½‚à‚µ‚È‚¢Žž‚Ì‹¤’ʏÁ”ïCP
     @active_battler.cp -=     0 if @phase4_act_continuation == 0
   when 1
     # ƒXƒLƒ‹Žg—pŽž‚̏Á”ïCP
     @active_battler.cp -= 65535 if @phase4_act_continuation == 0
   when 2
     # ƒAƒCƒeƒ€Žg—pŽž‚̏Á”ïCP
     @active_battler.cp -= 65535 if @phase4_act_continuation == 0
   when -1
     # CP‚ª—¬‚Ü‚Á‚Ä‚¢‚È‚¢
     @phase4_step = 6
     return
   end
   # CP‰ÁŽZ‚ðˆêŽž’âŽ~‚•‚é
   @cp_thread.stop = true
   # ƒXƒe[ƒgŽ©‘R‰ðœ
   @active_battler.remove_states_auto
   xrxs_bp1_update_phase4_step2
 end
 #--------------------------------------------------------------------------
 # œ Šî–{ƒAƒNƒVƒ‡ƒ“ Œ‹‰Êì¬
 #--------------------------------------------------------------------------
 alias xrxs_bp1_make_basic_action_result make_basic_action_result
 def make_basic_action_result
   # UŒ‚‚̏ꍇ
   if @active_battler.current_action.basic == 0 and @phase4_act_continuation == 0
     @active_battler.cp -= 65535 # UŒ‚Žž‚ÌCPÁ”ï
   end
   # –hŒä‚̏ꍇ
   if @active_battler.current_action.basic == 1 and @phase4_act_continuation == 0
     @active_battler.cp -= 32767 # –hŒäŽž‚ÌCPÁ”ï
   end
   # “G‚Ì“¦‚°‚é‚̏ꍇ
   if @active_battler.is_a?(Game_Enemy) and
      @active_battler.current_action.basic == 2 and @phase4_act_continuation == 0
     @active_battler.cp -= 65535 # “¦‘–Žž‚ÌCPÁ”ï
   end
   # ‰½‚à‚µ‚È‚¢‚̏ꍇ
   if @active_battler.current_action.basic == 3 and @phase4_act_continuation == 0
     @active_battler.cp -= 32767 # ‰½‚à‚µ‚È‚¢Žž‚ÌCPÁ”ï
   end
   # “¦‚°‚é‚̏ꍇ
   if @active_battler.current_action.basic == 4 and @phase4_act_continuation == 0
     @active_battler.cp -= 65535 # “¦‘–Žž‚ÌCPÁ”ï
     # “¦‘–‰Â”\‚Å‚Í‚È‚¢ê‡
     if $game_temp.battle_can_escape == false
       # ƒuƒU[ SE ‚ð‰‰‘t
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Œˆ’è SE ‚ð‰‰‘t
     $game_system.se_play($data_system.decision_se)
     # “¦‘–ˆ—
     update_phase2_escape
     return
   end
   xrxs_bp1_make_basic_action_result
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 5 : ƒ_ƒ[ƒW•\Ž¦)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_update_phase4_step5 update_phase4_step5
 def update_phase4_step5
   # ƒXƒŠƒbƒvƒ_ƒ[ƒW
   if @active_battler.hp > 0 and @active_battler.slip_damage?
     @active_battler.slip_damage_effect
     @active_battler.damage_pop = true
   end
   xrxs_bp1_update_phase4_step5
 end
 #--------------------------------------------------------------------------
 # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 6 : ƒŠƒtƒŒƒbƒVƒ…)
 #--------------------------------------------------------------------------
 alias xrxs_bp1_update_phase4_step6 update_phase4_step6
 def update_phase4_step6
   # CP‰ÁŽZ‚ðÄŠJ‚•‚é
   @cp_thread.stop = false
   # ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚ð‰B‚•
   @help_window.visible = false
   xrxs_bp1_update_phase4_step6
 end
end
# ¥£¥ XRXS_BP 7. ƒoƒgƒ‹ƒXƒe[ƒ^ƒXEƒNƒŠƒAƒfƒUƒCƒ“ ver.1.02 ¥£¥
# by ÷‰ë Ý“y, TOMY

#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
 #--------------------------------------------------------------------------
 # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
 #--------------------------------------------------------------------------
 attr_accessor   :update_cp_only                   # CPƒ[ƒ^[‚݂̂̍XV
 #--------------------------------------------------------------------------
 # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
 #--------------------------------------------------------------------------
 alias xrxs_bp7_initialize initialize
 def initialize
   xrxs_bp7_initialize
   # «Full-View‚̏ꍇ‚͉º“ñs‚Ì # ‚ðÁ‚µ‚Ä‚¬‚¾‚³‚¢B
   #self.opacity = 0
   #self.back_opacity = 0
 end
 #--------------------------------------------------------------------------
 # œ ƒŠƒtƒŒƒbƒVƒ…
 #--------------------------------------------------------------------------
 alias xrxs_bp7_refresh refresh
 def refresh
   if @update_cp_only
     xrxs_bp7_refresh
     return
   end
   # •`ŽÊ‚ð‹ÖŽ~‚µ‚È‚ª‚ç–ß‚•
   @draw_ban = true
   xrxs_bp7_refresh
   # •`ŽÊ‚Ì‹ÖŽ~‚ð‰ðœ
   @draw_ban = false
   # •`ŽÊ‚ðŠJŽn
   @item_max = $game_party.actors.size
   for i in 0...$game_party.actors.size
     actor = $game_party.actors
     actor_x = i * 160 + 21
     # •àsƒLƒƒƒ‰ƒOƒ‰ƒtƒBƒbƒN‚Ì•`ŽÊ
     draw_actor_graphic(actor, actor_x - 9, 116)
     # HP/SPƒ[ƒ^[‚Ì•`ŽÊ
     draw_actor_hp_meter_line(actor, actor_x,  72, 96, 12)
     draw_actor_sp_meter_line(actor, actor_x, 104, 96, 12)
     # HP”’l‚Ì•`ŽÊ
     self.contents.font.size = 24            # HP/SP”’l‚Ì•¶Žš‚Ì‘å‚«‚³
     self.contents.font.color = actor.hp == 0 ? knockout_color :
       actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
     draw_shadow_text(actor_x-2, 58, 96, 24, actor.hp.to_s, 2)
     # SP”’l‚Ì•`ŽÊ
     self.contents.font.color = actor.sp == 0 ? knockout_color :
       actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
     draw_shadow_text(actor_x-2, 90, 96, 24, actor.sp.to_s, 2)
     # —pŒêuHPv‚Æ—pŒêuSPv‚Ì•`ŽÊ
     self.contents.font.size = 12            # —pŒêuHP/SPv‚Ì•¶Žš‚Ì‘å‚«‚³
     self.contents.font.color = system_color # —pŒêuHP/SPv‚Ì•¶Žš‚̐F
     draw_shadow_text(actor_x, 60, 96, 12, $data_system.words.hp)
     draw_shadow_text(actor_x, 92, 96, 12, $data_system.words.sp)
     
     draw_actor_state(actor, actor_x, 100)
   end
 end
end
#==============================================================================
# ¡ Window_Base
#==============================================================================
class Window_Base < Window
 #--------------------------------------------------------------------------
 # œ HPƒ[ƒ^[ ‚Ì•`‰æ
 #--------------------------------------------------------------------------
 def draw_actor_hp_meter_line(actor, x, y, width = 156, height = 4)
   w = width * actor.hp / actor.maxhp
   hp_color_1 = Color.new(255,   0,   0, 192)
   hp_color_2 = Color.new(255, 255,   0, 192)
   self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
   x -= 1
   y += (height/4).floor
   self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
   x -= 1
   y += (height/4).ceil
   self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
   x -= 1
   y += (height/4).ceil
   self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
 end
 #--------------------------------------------------------------------------
 # œ SPƒ[ƒ^[ ‚Ì•`‰æ
 #--------------------------------------------------------------------------
 def draw_actor_sp_meter_line(actor, x, y, width = 156, height = 4)
   w = width * actor.sp / actor.maxsp
   hp_color_1 = Color.new(  0,   0, 255, 192)
   hp_color_2 = Color.new(  0, 255, 255, 192)
   self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
   x -= 1
   y += (height/4).floor
   self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
   x -= 1
   y += (height/4).ceil
   self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
   x -= 1
   y += (height/4).ceil
   self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
   draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
 end
 #--------------------------------------------------------------------------
 # œ –¼‘O‚Ì•`‰æ
 #--------------------------------------------------------------------------
 alias xrxs_bp7_draw_actor_name draw_actor_name
 def draw_actor_name(actor, x, y)
   xrxs_bp7_draw_actor_name(actor, x, y) if @draw_ban != true
 end
 #--------------------------------------------------------------------------
 # œ ƒXƒe[ƒg‚Ì•`‰æ
 #--------------------------------------------------------------------------
 alias xrxs_bp7_draw_actor_state draw_actor_state
 def draw_actor_state(actor, x, y, width = 120)
   xrxs_bp7_draw_actor_state(actor, x, y, width) if @draw_ban != true
 end
 #--------------------------------------------------------------------------
 # œ HP ‚Ì•`‰æ
 #--------------------------------------------------------------------------
 alias xrxs_bp7_draw_actor_hp draw_actor_hp
 def draw_actor_hp(actor, x, y, width = 144)
   xrxs_bp7_draw_actor_hp(actor, x, y, width) if @draw_ban != true
 end
 #--------------------------------------------------------------------------
 # œ SP ‚Ì•`‰æ
 #--------------------------------------------------------------------------
 alias xrxs_bp7_draw_actor_sp draw_actor_sp
 def draw_actor_sp(actor, x, y, width = 144)
   xrxs_bp7_draw_actor_sp(actor, x, y, width) if @draw_ban != true
 end
end
#==============================================================================
# ž ŠO•”ƒ‰ƒCƒuƒ‰ƒŠ
#==============================================================================
class Window_Base
 #--------------------------------------------------------------------------
 # œ ƒ‰ƒCƒ“•`‰æ by ÷‰ë Ý“y
 #--------------------------------------------------------------------------
 def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
   # •`ŽÊ‹——£‚ÌŒvŽZB‘å‚«‚ß‚É’¼ŠpŽž‚Ì’•‚³B
   distance = (start_x - end_x).abs + (start_y - end_y).abs
   # •`ŽÊŠJŽn
   if end_color == start_color
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       self.contents.fill_rect(x, y, width, width, start_color)
     end
   else
     for i in 1..distance
       x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
       y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
       r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance
       g = start_color.green * (distance-i)/distance + end_color.green * i/distance
       b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance
       a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
       self.contents.fill_rect(x, y, width, width, Color.new(r, g, b, a))
     end
   end
 end

 #--------------------------------------------------------------------------
 # œ ‰e•¶Žš•`‰æ by TOMY
 #--------------------------------------------------------------------------
 def draw_shadow_text(x, y, width, height, string, align = 0)
   # Œ³‚̐F‚ð•Û‘¶‚µ‚Ä‚¨‚¬
   color = self.contents.font.color.dup
   # •Žš‚ʼne•`‰æ
   self.contents.font.color = Color.new(0, 0, 0)
   self.contents.draw_text(x + 2, y + 2, width, height, string, align)
   # Œ³‚̐F‚É–ß‚µ‚Ä•`‰æ
   self.contents.font.color = color
   self.contents.draw_text(x, y, width, height, string, align)
 end
end

Spoiler for:

  class Bitmap
if not method_defined?('original_draw_text')
 alias original_draw_text draw_text
 def draw_text(*arg)

   original_color = self.font.color.dup
   self.font.color = Color.new(0, 0, 0, 128)

   if arg[0].is_a?(Rect)
     arg[0].x += 2
     arg[0].y += 2
     self.original_draw_text(*arg)
     arg[0].x -= 2
     arg[0].y -= 2
   else
     arg[0] += 2
     arg[1] += 2
     self.original_draw_text(*arg)
     arg[0] -= 2
     arg[1] -= 2
   end

   self.font.color = original_color
   self.original_draw_text(*arg)

 end
end
def gradation_rect(x, y, width, height, color1, color2, align = 0)
 if align == 0
   for i in x...x + width
     red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
     green = color1.green +
             (color2.green - color1.green) * (i - x) / (width - 1)
     blue  = color1.blue +
             (color2.blue - color1.blue) * (i - x) / (width - 1)
     alpha = color1.alpha +
             (color2.alpha - color1.alpha) * (i - x) / (width - 1)
     color = Color.new(red, green, blue, alpha)
     fill_rect(i, y, 1, height, color)
   end
 elsif align == 1
   for i in y...y + height
     red   = color1.red +
             (color2.red - color1.red) * (i - y) / (height - 1)
     green = color1.green +
             (color2.green - color1.green) * (i - y) / (height - 1)
     blue  = color1.blue +
             (color2.blue - color1.blue) * (i - y) / (height - 1)
     alpha = color1.alpha +
             (color2.alpha - color1.alpha) * (i - y) / (height - 1)
     color = Color.new(red, green, blue, alpha)
     fill_rect(x, i, width, 1, color)
   end
 elsif align == 2
   for i in x...x + width
     for j in y...y + height
       red   = color1.red + (color2.red - color1.red) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       green = color1.green + (color2.green - color1.green) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       blue  = color1.blue + (color2.blue - color1.blue) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       alpha = color1.alpha + (color2.alpha - color1.alpha) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       color = Color.new(red, green, blue, alpha)
       set_pixel(i, j, color)
     end
   end
 elsif align == 3
   for i in x...x + width
     for j in y...y + height
       red   = color1.red + (color2.red - color1.red) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       green = color1.green + (color2.green - color1.green) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       blue  = color1.blue + (color2.blue - color1.blue) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       alpha = color1.alpha + (color2.alpha - color1.alpha) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       color = Color.new(red, green, blue, alpha)
       set_pixel(i, j, color)
     end
   end
 end
end
end

module RPG
class Sprite < ::Sprite
 def damage(value, critical)
   dispose_damage
   if value.is_a?(Numeric)
     damage_string = value.abs.to_s
   else
     damage_string = value.to_s
   end
   bitmap = Bitmap.new(160, 48)
   bitmap.font.name = "Arial Black"
   bitmap.font.size = 32
   bitmap.font.color.set(0, 0, 0)
   bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
   bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
   bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
   bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
   if value.is_a?(Numeric) and value < 0
     bitmap.font.color.set(176, 255, 144)
   else
     bitmap.font.color.set(255, 255, 255)
   end
   bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
   if critical
     bitmap.font.size = 20
     bitmap.font.color.set(0, 0, 0)
     bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
     bitmap.font.color.set(255, 255, 255)
     bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
   end
   @_damage_sprite = ::Sprite.new
   @_damage_sprite.bitmap = bitmap
   @_damage_sprite.ox = 80 + self.viewport.ox
   @_damage_sprite.oy = 20 + self.viewport.oy
   @_damage_sprite.x = self.x + self.viewport.rect.x
   @_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
   @_damage_sprite.z = 3000
   @_dam

Fix your script, you need to use [code"][/code"] tags (remove the " of course).

that second script isn't complete.  Also, what is the error you get?  That may be helpful in determining what's causing the problem.

Good post Shaz, but you forgot to curse at him.

http://rmrk.net/index.php/topic,19774.0.html

  The error comes up during battle

??'ATB' ? 772 NoMethodError ??
undefined method 'update_cp_only=' for nil:NilClass

Spoiler for:

class Bitmap
if not method_defined?('original_draw_text')
 alias original_draw_text draw_text
 def draw_text(*arg)

   original_color = self.font.color.dup
   self.font.color = Color.new(0, 0, 0, 128)

   if arg[0].is_a?(Rect)
     arg[0].x += 2
     arg[0].y += 2
     self.original_draw_text(*arg)
     arg[0].x -= 2
     arg[0].y -= 2
   else
     arg[0] += 2
     arg[1] += 2
     self.original_draw_text(*arg)
     arg[0] -= 2
     arg[1] -= 2
   end

   self.font.color = original_color
   self.original_draw_text(*arg)

 end
end
def gradation_rect(x, y, width, height, color1, color2, align = 0)
 if align == 0
   for i in x...x + width
     red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
     green = color1.green +
             (color2.green - color1.green) * (i - x) / (width - 1)
     blue  = color1.blue +
             (color2.blue - color1.blue) * (i - x) / (width - 1)
     alpha = color1.alpha +
             (color2.alpha - color1.alpha) * (i - x) / (width - 1)
     color = Color.new(red, green, blue, alpha)
     fill_rect(i, y, 1, height, color)
   end
 elsif align == 1
   for i in y...y + height
     red   = color1.red +
             (color2.red - color1.red) * (i - y) / (height - 1)
     green = color1.green +
             (color2.green - color1.green) * (i - y) / (height - 1)
     blue  = color1.blue +
             (color2.blue - color1.blue) * (i - y) / (height - 1)
     alpha = color1.alpha +
             (color2.alpha - color1.alpha) * (i - y) / (height - 1)
     color = Color.new(red, green, blue, alpha)
     fill_rect(x, i, width, 1, color)
   end
 elsif align == 2
   for i in x...x + width
     for j in y...y + height
       red   = color1.red + (color2.red - color1.red) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       green = color1.green + (color2.green - color1.green) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       blue  = color1.blue + (color2.blue - color1.blue) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       alpha = color1.alpha + (color2.alpha - color1.alpha) *
               ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       color = Color.new(red, green, blue, alpha)
       set_pixel(i, j, color)
     end
   end
 elsif align == 3
   for i in x...x + width
     for j in y...y + height
       red   = color1.red + (color2.red - color1.red) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       green = color1.green + (color2.green - color1.green) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       blue  = color1.blue + (color2.blue - color1.blue) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       alpha = color1.alpha + (color2.alpha - color1.alpha) *
             ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
       color = Color.new(red, green, blue, alpha)
       set_pixel(i, j, color)
     end
   end
 end
end
end

module RPG
class Sprite < ::Sprite
 def damage(value, critical)
   dispose_damage
   if value.is_a?(Numeric)
     damage_string = value.abs.to_s
   else
     damage_string = value.to_s
   end
   bitmap = Bitmap.new(160, 48)
   bitmap.font.name = "Arial Black"
   bitmap.font.size = 32
   bitmap.font.color.set(0, 0, 0)
   bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
   bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
   bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
   bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
   if value.is_a?(Numeric) and value < 0
     bitmap.font.color.set(176, 255, 144)
   else
     bitmap.font.color.set(255, 255, 255)
   end
   bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
   if critical
     bitmap.font.size = 20
     bitmap.font.color.set(0, 0, 0)
     bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
     bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
     bitmap.font.color.set(255, 255, 255)
     bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
   end
   @_damage_sprite = ::Sprite.new
   @_damage_sprite.bitmap = bitmap
   @_damage_sprite.ox = 80 + self.viewport.ox
   @_damage_sprite.oy = 20 + self.viewport.oy
   @_damage_sprite.x = self.x + self.viewport.rect.x
   @_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
   @_damage_sprite.z = 3000
   @_damage_duration = 40
 end
 def animation(animation, hit)
   dispose_animation
   @_animation = animation
   return if @_animation == nil
   @_animation_hit = hit
   @_animation_duration = @_animation.frame_max
   animation_name = @_animation.animation_name
   animation_hue = @_animation.animation_hue
   bitmap = RPG::Cache.animation(animation_name, animation_hue)
   if @@_reference_count.include?(bitmap)
     @@_reference_count[bitmap] += 1
   else
     @@_reference_count[bitmap] = 1
   end
   @_animation_sprites = []
   if @_animation.position != 3 or not @@_animations.include?(animation)
     for i in 0..15
       sprite = ::Sprite.new
       sprite.bitmap = bitmap
       sprite.visible = false
       @_animation_sprites.push(sprite)
     end
     unless @@_animations.include?(animation)
       @@_animations.push(animation)
     end
   end
   update_animation
 end
 def loop_animation(animation)
   return if animation == @_loop_animation
   dispose_loop_animation
   @_loop_animation = animation
   return if @_loop_animation == nil
   @_loop_animation_index = 0
   animation_name = @_loop_animation.animation_name
   animation_hue = @_loop_animation.animation_hue
   bitmap = RPG::Cache.animation(animation_name, animation_hue)
   if @@_reference_count.include?(bitmap)
     @@_reference_count[bitmap] += 1
   else
     @@_reference_count[bitmap] = 1
   end
   @_loop_animation_sprites = []
   for i in 0..15
     sprite = ::Sprite.new
     sprite.bitmap = bitmap
     sprite.visible = false
     @_loop_animation_sprites.push(sprite)
   end
   update_loop_animation
 end
 def animation_set_sprites(sprites, cell_data, position)
   for i in 0..15
     sprite = sprites
     pattern = cell_data[i, 0]
     if sprite == nil or pattern == nil or pattern == -1
       sprite.visible = false if sprite != nil
       next
     end
     sprite.visible = true
     sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
     if position == 3
       if self.viewport != nil
         sprite.x = self.viewport.rect.width / 2
         sprite.y = self.viewport.rect.height - 160
       else
         sprite.x = 320
         sprite.y = 240
       end
     else
       sprite.x = self.x + self.viewport.rect.x -
                   self.ox + self.src_rect.width / 2
       sprite.y = self.y + self.viewport.rect.y -
                   self.oy + self.src_rect.height / 2
       sprite.y -= self.src_rect.height / 4 if position == 0
       sprite.y += self.src_rect.height / 4 if position == 2
     end
     sprite.x += cell_data[i, 1]
     sprite.y += cell_data[i, 2]
     sprite.z = 2000
     sprite.ox = 96
     sprite.oy = 96
     sprite.zoom_x = cell_data[i, 3] / 100.0
     sprite.zoom_y = cell_data[i, 3] / 100.0
     sprite.angle = cell_data[i, 4]
     sprite.mirror = (cell_data[i, 5] == 1)
     sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
     sprite.blend_type = cell_data[i, 7]
   end
 end
end
end

class Game_Actor < Game_Battler
 def screen_x
   if self.index != nil
   n_split = [($game_party.actors.length * 0.5).ceil, 4].min
   case n_split
   when 1
     n_index = self.index * 2
   when 2
     if self.index < ($game_party.actors.length - 2)
       n_index = 0.5 + (2 * self.index)
     else
       if $game_party.actors.length == 3 then
         n_index = (self.index * 2) + 2
       elsif $game_party.actors.length == 4 then
         n_index = self.index * 2
       end
     end
   when 3
       n_index = self.index + (0.25 * (self.index + 1))
     if $game_party.actors.length == 5
     if self.index < 2
       n_index = self.index + (0.25 * (self.index + 1))
     else
       n_index = self.index + (0.25 * (self.index + 2)) + 1
     end
     end
   when 4
     n_index = self.index
     if $game_party.actors.length == 7
     if self.index < 3
       n_index = self.index
     else
       n_index = self.index + 1
     end
     end
   end
     return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) / 5) + 480 + ((n_index / 4).floor * 60)
   else
     return 0
   end
 end
 #--------------------------------------------------------------------------
 # ? ?? Y ??
 #--------------------------------------------------------------------------
 def screen_y
   n_split = [($game_party.actors.length * 0.5).ceil, 4].min
   case n_split
   when 1
     n_index = self.index * 2
   when 2
     if self.index < ($game_party.actors.length - 2)
       n_index = 0.5 + (2 * self.index)
     else
       if $game_party.actors.length == 3 then
         n_index = (self.index * 2) + 2
       elsif $game_party.actors.length == 4 then
         n_index = self.index * 2
       end
     end
   when 3
       n_index = self.index + (0.25 * (self.index + 1))
     if $game_party.actors.length == 5
     if self.index < 2
       n_index = self.index + (0.25 * (self.index + 1))
     else
       n_index = self.index + (0.25 * (self.index + 2)) + 1
     end
     end
   when 4
     n_index = self.index
     if $game_party.actors.length == 7
     if self.index < 3
       n_index = self.index
     else
       n_index = self.index + 1
     end
     end
   end
   return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) * 1.6) + 270 - ((n_index / 4).floor * (110 - (4 * 20)))
end
 #--------------------------------------------------------------------------
 # ? ?? Z ??
 #--------------------------------------------------------------------------
 def screen_z
   # ?? Z
   if self.index != nil
     return self.index
   else
     return 0
   end
 end
end

class Game_Enemy < Game_Battler
 def screen_x
   n_split = [($game_troop.enemies.length * 0.5).ceil, 4].min
   case n_split
   when 1
     n_index = self.index * 2
   when 2
     if self.index < ($game_troop.enemies.length - 2)
       n_index = 0.5 + (2 * self.index)
     else
       if $game_troop.enemies.length == 3 then
         n_index = (self.index * 2) + 2
       elsif $game_troop.enemies.length == 4 then
         n_index = self.index * 2
       end
     end
   when 3
       n_index = self.index + (0.25 * (self.index + 1))
     if $game_troop.enemies.length == 5
     if self.index < 2
       n_index = self.index + (0.25 * (self.index + 1))
     else
       n_index = self.index + (0.25 * (self.index + 2)) + 2
     end
     end
   when 4
     n_index = self.index
     if $game_troop.enemies.length == 7
     if self.index < 3
       n_index = self.index
     else
       n_index = self.index + 1
     end
     end
   end
   return (n_index - ((n_index / 4).floor) * 4) * ((-160 / (4)) / 5) + 160 - ((n_index / 4).floor * 60)
 end
 #--------------------------------------------------------------------------
 # ? ?? Y ??
 #--------------------------------------------------------------------------
 def screen_y
   n_split = [($game_troop.enemies.length * 0.5).ceil, 4].min
   case n_split
   when 1
     n_index = self.index * 2
   when 2
     if self.index < ($game_troop.enemies.length - 2)
       n_index = 0.5 + (2 * self.index)
     else
       if $game_troop.enemies.length == 3 then
         n_index = (self.index * 2) + 2
       elsif $game_troop.enemies.length == 4 then
         n_index = self.index * 2
       end
     end
   when 3
       n_index = self.index + (0.25 * (self.index + 1))
     if $game_troop.enemies.length == 5
     if self.index < 2
       n_index = self.index + (0.25 * (self.index + 1))
     else
       n_index = self.index + (0.25 * (self.index + 2)) + 1
     end
     end
   when 4
     n_index = self.index
     if $game_troop.enemies.length == 7
     if self.index < 3
       n_index = self.index
     else
       n_index = self.index + 1
     end
     end
   end
   return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) * 1.6) + 270 - ((n_index / 4).floor * (110 - (4 * 20)))
 end
 #--------------------------------------------------------------------------
 # ? ?? Z ??
 #--------------------------------------------------------------------------
 def screen_z
   return @member_index + 1
 end
end

#==============================================================================
# ¦ Sprite_Battler
#------------------------------------------------------------------------------
#  ?Game_Battler
# ??
#==============================================================================

class Sprite_Battler < RPG::Sprite
 #--------------------------------------------------------------------------
 # ? ?
 #--------------------------------------------------------------------------
 attr_accessor :battler                  # ?
 attr_accessor :moving        # Is the sprite moving?
 attr_reader   :index
 attr_accessor :target_index
 attr_accessor :direction
 attr_accessor :pattern
 #--------------------------------------------------------------------------
 # ?
 #     viewport :
 #     battler  : ? (Game_Battler)
 #--------------------------------------------------------------------------
 def initialize(viewport, battler = nil)
   super(viewport)
   change
   @old = Graphics.frame_count  # For the delay method
   @goingup = true    # Increasing animation? (if @rm2k_mode is true)
   @once = false      # Is the animation only played once?
   @animated = true   # Used to stop animation when @once is true
   self.opacity = 0
   @index = 0
   @pattern_b = 0
   @counter_b = 0
   @trans_sprite = Sprite.new
   @trans_sprite.opacity = 0
   @bar_hp_sprite = Sprite.new
   @bar_hp_sprite.bitmap = Bitmap.new(64, 10)
   @bar_sp_sprite = Sprite.new
   @bar_sp_sprite.bitmap = Bitmap.new(64, 10)
   @color1 = Color.new(0, 0, 0, 192)
   @color2 = Color.new(255, 255, 192, 192)
   @color3 = Color.new(0, 0, 0, 192)
   @color4 = Color.new(64, 0, 0, 192)
   @old_hp = -1
   @old_sp = -1
   @battler = battler
   @battler_visible = false
   @first = true
   @pattern = 0
   if $target_index == nil
     $target_index = 0
   end
   @battler.is_a?(Game_Enemy) ? enemy_pose(0, 1) : pose(0, 1)
 end
 #--------------------------------------------------------------------------
 # ? ??
 #--------------------------------------------------------------------------
 def dispose
   if self.bitmap != nil
     self.bitmap.dispose
   end
   if @trans_sprite.bitmap != nil
     @trans_sprite.bitmap.dispose
   end
   @trans_sprite.dispose
   @bar_hp_sprite.bitmap.dispose
   @bar_hp_sprite.dispose
   @bar_sp_sprite.bitmap.dispose
   @bar_sp_sprite.dispose
   super
 end
 
 def change(frames = 0, delay = 0, offx = 0, offy = 0, startf = 0, once = false)
   @frames = frames
   @delay = delay
   @offset_x, @offset_y = offx, offy
   @current_frame = startf
   @once = once
   @goingup = true
   @animated = true
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update
   bar_check = true if @_damage_duration == 1
   super
   @trans_sprite.blend_type = self.blend_type
   @trans_sprite.color = self.color
   if @_collapse_duration > 0
     @trans_sprite.opacity = self.opacity
   else
     @trans_sprite.opacity = [self.opacity, 160].min
   end
   if (@_damage_duration == 0 and bar_check == true) or @first == true
     @first = false if @first == true
     bar_check = false
     @bar_must_change = true
   end
   @bar_hp_sprite.opacity = self.opacity
   @bar_sp_sprite.opacity = self.opacity
   # ?? nil
   if @battler == nil
     self.bitmap = nil
     @trans_sprite.bitmap = nil
     loop_animation(nil)
     return
   end
   # ??
   if @battler.battler_name != @battler_name or
      @battler.battler_hue != @battler_hue
     #
     @battler_name = @battler.battler_name
     @battler_hue = @battler.battler_hue
     if @battler.is_a?(Game_Actor)
       @battler_name = @battler.character_name
       @battler_hue = @battler.character_hue
       @direction = 4
     else
       @direction = 6
     end
       self.bitmap = RPG::Cache.character(@battler_name, @battler_hue)
       @width = bitmap.width / 4
       @height = bitmap.height / 4
       @frame_width = @width
       @frame_height = @height
       self.ox = @width / 2
       self.oy = @height
       @pattern = @current_frame
       @direction = @offset_y
       sx = @pattern * @width
       sy = (@direction - 2) / 2 * @height
       self.src_rect.set(sx, sy, @width, @height)
       @current_frame = (@current_frame + 1) unless @frames == 0
       @animated = false if @current_frame == @frames and @once
       @current_frame %= @frames
       @trans_sprite.bitmap = self.bitmap
       @trans_sprite.ox = self.ox
       @trans_sprite.oy = self.oy
       @trans_sprite.src_rect.set(sx, sy, @width, @height)
     # 0
     if @battler.dead? or @battler.hidden
       self.opacity = 0
       @trans_sprite.opacity = 0
       @bar_hp_sprite.opacity = 0
       @bar_sp_sprite.opacity = 0
     end
   self.x = @battler.screen_x
   self.y = @battler.screen_y
   self.z = @battler.screen_z
 end
 change_sp_bar if @old_sp != @battler.sp
 if delay(@delay) and @animated
     @pattern = @current_frame
     @direction = @offset_y
     sx = @pattern * @width
     sy = (@direction - 2) / 2 * @height
     self.src_rect.set(sx, sy, @width, @height)
     @current_frame = (@current_frame + 1) unless @frames == 0
     @animated = false if @current_frame == @frames and @once
     @current_frame %= @frames
     @trans_sprite.ox = self.ox
     @trans_sprite.oy = self.oy
     @trans_sprite.src_rect.set(sx, sy, @width, @height)
   end
   # ? ID
   if @battler.damage == nil and
      @battler.state_animation_id != @state_animation_id
     @state_animation_id = @battler.state_animation_id
     loop_animation($data_animations[@state_animation_id])
   end
   # ??
   #if @battler.is_a?(Game_Actor) and @battler_visible
     # ??
     #if $game_temp.battle_main_phase
       #self.opacity += 3 if self.opacity < 255
     #else
       #self.opacity -= 3 if self.opacity > 207
     #end
   #end
   # ??
   if @battler.blink
     blink_on
   else
     blink_off
   end
   #
   unless @battler_visible
     # ??
     if not @battler.hidden and not @battler.dead? and
        (@battler.damage == nil or @battler.damage_pop)
       appear
       @battler_visible = true
     end
   end
   # ??
   if @battler_visible
     # ??
     if @battler.hidden
       $game_system.se_play($data_system.escape_se)
       escape
       @trans_sprite.opacity = 0
       @battler_visible = false
     end
     #
     if @battler.white_flash
       whiten
       @battler.white_flash = false
     end
     # ?
     if @battler.animation_id != 0
       animation = $data_animations[@battler.animation_id]
       animation(animation, @battler.animation_hit)
       @battler.animation_id = 0
     end
     # ?
     if @battler.damage_pop
       damage(@battler.damage, @battler.critical)
       @battler.damage = nil
       @battler.critical = false
       @battler.damage_pop = false
     end
     if @bar_must_change == true
       @bar_must_change = false
       if @old_hp != @battler.hp
         change_hp_bar
       end
       if @battler.damage == nil and @battler.dead?
         if @battler.is_a?(Game_Enemy)
           $game_system.se_play($data_system.enemy_collapse_se)
         else
           $game_system.se_play($data_system.actor_collapse_se)
         end
         collapse
         @battler_visible = false
       end
     end
   end
   # ??
   @trans_sprite.x = self.x
   @trans_sprite.y = self.y
   @trans_sprite.z = self.z
   @bar_hp_sprite.x = @battler.screen_x - 32
   @bar_hp_sprite.y = @battler.screen_y - (@height +18) if @height != nil
   @bar_hp_sprite.z = 100
   @bar_sp_sprite.x = @battler.screen_x - 32
   @bar_sp_sprite.y = @battler.screen_y - (@height + if @height != nil
   @bar_sp_sprite.z = 100
 end
 
 #--------------------------------------------------------------------------
 # - Move the sprite
 #   x : X coordinate of the destination point
 #   y : Y coordinate of the destination point
 #   speed : Speed of movement (0 = delayed, 1+ = faster)
 #   delay : Movement delay if speed is at 0
 #--------------------------------------------------------------------------
 def move(x, y, speed = 1, delay = 0)
   @destx = x
   @desty = y
   @move_speed = speed
   @move_delay = delay
   @move_old = Graphics.frame_count
   @moving = true
 end
 
 #--------------------------------------------------------------------------
 # - Move sprite to destx and desty
 #--------------------------------------------------------------------------
 def update_move
   return unless @moving
   movinc = @move_speed == 0 ? 1 : @move_speed
   if Graphics.frame_count - @move_old > @move_delay or @move_speed != 0
     self.x += movinc if self.x < @destx
     self.x -= movinc if self.x > @destx
     self.y += movinc if self.y < @desty
     self.y -= movinc if self.y > @desty
     @move_old = Graphics.frame_count
   end
   if @move_speed > 1  # Check if sprite can't reach that point
     self.x = @destx if (@destx - self.x).abs % @move_speed != 0 and
                        (@destx - self.x).abs <= @move_speed
     self.y = @desty if (@desty - self.y).abs % @move_speed != 0 and
                        (@desty - self.y).abs <= @move_speed
   end
   if self.x == @destx and self.y == @desty
     @moving = false
   end
 end
 
 #--------------------------------------------------------------------------
 # - Pause animation, but still updates movement
 #   frames : Number of frames
 #--------------------------------------------------------------------------
 def delay(frames)
   update_move
   if (Graphics.frame_count - @old >= frames)
     @old = Graphics.frame_count
     return true
   end
   return false
 end
 
 def change_hp_bar
   j = false
  @old_hp = @battler.hp if @old_hp == -1
   i = @old_hp
   loop do
     i -= 10
     if i < @battler.hp
       i = @battler.hp
       j = true
     end
     rate = i.to_f / @battler.maxhp
     @color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
     @color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
     @bar_hp_sprite.bitmap.clear
     @bar_hp_sprite.bitmap.fill_rect(0, 0, 64, 10, @color1)
     @bar_hp_sprite.bitmap.fill_rect(1, 1, 62, 8, @color2)
     @bar_hp_sprite.bitmap.gradation_rect(2, 2, 60, 6, @color3, @color4, 1)
     #@bar_hp_sprite.bitmap.fill_rect(2, 2, 60, 6, @color3)
     @bar_hp_sprite.bitmap.gradation_rect(2, 2, 64 * rate - 4, 6, @color5, @color6, 2)
     #@bar_hp_sprite.bitmap.fill_rect(2, 2, 64 * rate - 4, 6, @color5)
     @bar_hp_sprite.opacity = self.opacity
     Graphics.update
     if j == true
       j = false
       break
     end
   end
   @old_hp = @battler.hp
 end
 
 def change_sp_bar
   j = false
  @old_sp = @battler.sp if @old_sp == -1
   i = @old_sp
   loop do
     i -= 10
     if i < @battler.sp
       i = @battler.sp
       j = true
     end
     rate = i.to_f / @battler.maxsp
     @color7 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
     @color8 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
     @bar_sp_sprite.bitmap.clear
     @bar_sp_sprite.bitmap.fill_rect(0, 0, 64, 10, @color1)
     @bar_sp_sprite.bitmap.fill_rect(1, 1, 62, 8, @color2)
     @bar_sp_sprite.bitmap.gradation_rect(2, 2, 60, 6, @color3, @color4, 1)
     #@bar_hp_sprite.bitmap.fill_rect(2, 2, 60, 6, @color3)
     @bar_sp_sprite.bitmap.gradation_rect(2, 2, 64 * rate - 4, 6, @color7, @color8, 0)
     #@bar_hp_sprite.bitmap.fill_rect(2, 2, 64 * rate - 4, 6, @color5)
     @bar_sp_sprite.opacity = self.opacity
     Graphics.update
     if j == true
       j = false
       break
     end
   end
   @old_sp = @battler.sp
 end
 
 def enemy                                             #
   $target_index += $game_troop.enemies.size
   $target_index %= $game_troop.enemies.size
   return $game_troop.enemies[$target_index]           #
 end                                                   #
 
 def actor                                             #
   $target_index += $game_party.actors.size
   $target_index %= $game_party.actors.size
   return $game_party.actors[$target_index]            #
 end
 
 def index=(index)
   @index = index
   update
 end
 
   def pose(number, frames = 4)
   case number
   when 0
     change(frames, 4, 0, 4, 0)
   when 1
     change(frames, 4, 0, 4)
   when 2
     change(frames, 4, 0, 6)
   else
     change(frames, 4, 0, 0, 0)
   end
 end
 
   def enemy_pose(number ,enemy_frames = 4)
   case number
   when 0
     change(enemy_frames, 4, 0, 6, 0)
   when 1
     change(enemy_frames, 4, 0, 4)
   when 2
     change(enemy_frames, 4, 0, 6)
   else
     change(enemy_frames, 4, 0, 0, 0)
   end
 end
 
 def default_pose
   pose(0, 1)
 end
end

#==============================================================================
# ¦ Spriteset_Battle
#------------------------------------------------------------------------------
#  ? Scene_Battle ??
#
#==============================================================================

class Spriteset_Battle
 #--------------------------------------------------------------------------
 # ? ?
 #--------------------------------------------------------------------------
 attr_reader   :viewport1                #
 attr_reader   :viewport2                #
 attr_accessor :actor_sprites
 attr_accessor :enemy_sprites
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def initialize
   #
   @viewport1 = Viewport.new(0, 0, 640, 480)
   @viewport2 = Viewport.new(0, 0, 640, 480)
   @viewport3 = Viewport.new(0, 0, 640, 480)
   @viewport4 = Viewport.new(0, 0, 640, 480)
   @viewport2.z = 101
   @viewport3.z = 200
   @viewport4.z = 5000
   if $game_temp.battleback_name == ""
   @battleback_sprite = nil
   @tilemap = Tilemap.new(@viewport1)
   @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
   for i in 0..6
     autotile_name = $game_map.autotile_names
     @tilemap.autotiles = RPG::Cache.autotile(autotile_name)
   end
   @tilemap.map_data = $game_map.data
   @tilemap.priorities = $game_map.priorities
   else
   # ??
   @tilemap = nil
   @battleback_sprite = Sprite.new(@viewport1)
   end
   #
   @enemy_sprites = []
   for enemy in $game_troop.enemies#.reverse
     @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
   end
   #
   @actor_sprites = []
   for j in 0..7
       # ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ð’ljÁ
       @actor_sprites.push(Sprite_Battler.new(@viewport1, $game_party.actors[j]))
   end
   # ??
   @weather = RPG::Weather.new(@viewport1)
   #
   @picture_sprites = []
   for i in 51..100
     @picture_sprites.push(Sprite_Picture.new(@viewport3,
       $game_screen.pictures))
   end
   #
   @timer_sprite = Sprite_Timer.new
   #
   update
 end
 #--------------------------------------------------------------------------
 # ? ??
 #--------------------------------------------------------------------------
 def dispose
   if @tilemap != nil
   #
   @tilemap.tileset.dispose
   for i in 0..6
     @tilemap.autotiles.dispose
   end
   @tilemap.dispose
   end
   # ??
   if @battleback_sprite != nil
   # ?
   if @battleback_sprite.bitmap != nil
     @battleback_sprite.bitmap.dispose
   end
   @battleback_sprite.dispose
   end
   # ?
   for sprite in @enemy_sprites + @actor_sprites
     sprite.dispose
   end
   # ??
   @weather.dispose
   #
   for sprite in @picture_sprites
     sprite.dispose
   end
   #
   @timer_sprite.dispose
   #
   @viewport1.dispose
   @viewport2.dispose
   @viewport3.dispose
   @viewport4.dispose
 end
 #--------------------------------------------------------------------------
 # ? ?
 #--------------------------------------------------------------------------
 def effect?
   # true
   for sprite in @enemy_sprites + @actor_sprites
     return true if sprite.effect?
   end
   return false
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update
   # ??
   if @battleback_sprite != nil
   if @battleback_name != $game_temp.battleback_name
     @battleback_name = $game_temp.battleback_name
     if @battleback_sprite.bitmap != nil
       @battleback_sprite.bitmap.dispose
     end
     bg_bitmap = RPG::Cache.battleback(@battleback_name)
     bg_bitmap_stretch = Bitmap.new(640, 480)
     bg_bitmap_stretch.stretch_blt(Rect.new(0, 0, 640, 480), bg_bitmap, bg_bitmap.rect)
     @battleback_sprite.bitmap = bg_bitmap_stretch
   end
   end
   if @tilemap != nil
   @tilemap.ox = $game_map.display_x / 4
   @tilemap.oy = $game_map.display_y / 4
   @tilemap.update
   end
   #
   for sprite in @enemy_sprites + @actor_sprites
     sprite.update
   end
   # ??
   @weather.type = $game_screen.weather_type
   @weather.max = $game_screen.weather_max
   @weather.update
   #
   for sprite in @picture_sprites
     sprite.update
   end
   #
   @timer_sprite.update
   #
   @viewport1.tone = $game_screen.tone
   @viewport1.ox = $game_screen.shake
   #
   @viewport4.color = $game_screen.flash_color
   #
   @viewport1.update
   @viewport2.update
   @viewport4.update
 end
end

#==============================================================================
# ¦ Window_Command
#------------------------------------------------------------------------------
# 
#==============================================================================

class Window_Command < Window_Selectable
 #--------------------------------------------------------------------------
 # ?
 #     width    : ?
 #     commands : ?
 #--------------------------------------------------------------------------
 def initialize(width, commands, column_max = 1, style = 0, inf_scroll = 1)
   # ??
   super(0, 0, width, (commands.size * 1.0 / column_max).ceil * 32 + 32)
   @inf_scroll = inf_scroll
   @item_max = commands.size
   @commands = commands
   @column_max = column_max
   @style = style
   self.contents = Bitmap.new(width - 32, (@item_max * 1.0 / @column_max).ceil * 32)
   self.contents.font.name = "Tahoma"
   self.contents.font.size = 22
   refresh
   self.index = 0
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   for i in 0...@item_max
     draw_item(i, normal_color)
   end
 end
 #--------------------------------------------------------------------------
 # ? ??
 #     index : ?
 #     color :
 #--------------------------------------------------------------------------
 def draw_item(index, color)
   self.contents.font.color = color
   rect = Rect.new(index%@column_max * (self.width / @column_max) + 4, 32 * (index/@column_max), self.width / @column_max - 40, 32)
   self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
   self.contents.draw_text(rect, @commands[index], @style)
 end
 #--------------------------------------------------------------------------
 # ?
 #     index : ?
 #--------------------------------------------------------------------------
 def disable_item(index)
   draw_item(index, disabled_color)
 end
 
 def update_help
   @help_window.set_actor($game_party.actors[$scene.actor_index])
 end
end

#==============================================================================
# ¦ Arrow_Enemy
#------------------------------------------------------------------------------
#  ?? Arrow_Base ??
# ??
#==============================================================================

class Arrow_Enemy < Arrow_Base
 #--------------------------------------------------------------------------
 # ? ??
 #--------------------------------------------------------------------------
 def enemy
   return $game_troop.enemies[@index]
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update
   super
   # ?
   $game_troop.enemies.size.times do
     break if self.enemy.exist?
     @index += 1
     @index %= $game_troop.enemies.size
   end
   # ??
   if Input.repeat?(Input::DOWN)
     $game_system.se_play($data_system.cursor_se)
     $game_troop.enemies.size.times do
       @index += 1
       @index %= $game_troop.enemies.size
       break if self.enemy.exist?
     end
   end
   # ??
   if Input.repeat?(Input::UP)
     $game_system.se_play($data_system.cursor_se)
     $game_troop.enemies.size.times do
       @index += $game_troop.enemies.size - 1
       @index %= $game_troop.enemies.size
       break if self.enemy.exist?
     end
   end
   if Input.repeat?(Input::RIGHT)
     $game_system.se_play($data_system.cursor_se)
     $game_troop.enemies.size.times do
       @index += ((($game_troop.enemies.length) * 0.5).ceil)
       @index %= $game_troop.enemies.size
       break if self.enemy.exist?
     end
   end
   if Input.repeat?(Input::LEFT)
     $game_system.se_play($data_system.cursor_se)
     $game_troop.enemies.size.times do
       @index += $game_troop.enemies.size - ((($game_troop.enemies.length) * 0.5).ceil)
       @index %= $game_troop.enemies.size
       break if self.enemy.exist?
     end
   end
   # ??
   if self.enemy != nil
     self.x = self.enemy.screen_x + 4
     self.y = self.enemy.screen_y + 36
     self.z = self.enemy.screen_z + 1
   end
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update_help
   #
   @help_window.set_enemy(self.enemy)
 end
end

#==============================================================================
# ¦ Arrow_Actor
#------------------------------------------------------------------------------
#  ?? Arrow_Base ??
# ??
#==============================================================================

class Arrow_Actor < Arrow_Base
 #--------------------------------------------------------------------------
 # ? ??
 #--------------------------------------------------------------------------
 def actor
   return $game_party.actors[@index]
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update
   super
   # ??
   if Input.repeat?(Input::DOWN)
     $game_system.se_play($data_system.cursor_se)
     @index += 1
     @index %= $game_party.actors.size
   end
   # ??
   if Input.repeat?(Input::UP)
     $game_system.se_play($data_system.cursor_se)
     @index += $game_party.actors.size - 1
     @index %= $game_party.actors.size
   end
   if Input.repeat?(Input::RIGHT)
     $game_system.se_play($data_system.cursor_se)
     @index += ($game_party.actors.length * 0.5).ceil
     @index %= $game_party.actors.size
   end
   # ??
   if Input.repeat?(Input::LEFT)
     $game_system.se_play($data_system.cursor_se)
     @index += $game_party.actors.size - (($game_party.actors.length * 0.5).ceil)
     @index %= $game_party.actors.size
   end
   # ??
   if self.actor != nil
     self.x = self.actor.screen_x
     self.y = self.actor.screen_y + 36
     self.z = self.actor.screen_z + 1
   end
 end
 #--------------------------------------------------------------------------
 # ?
 #--------------------------------------------------------------------------
 def update_help
   # ?
   @help_window.set_actor(self.actor)
 end
end

class Scene_Battle
 attr_accessor :actor_index
 def main
   #
   $game_temp.in_battle = true
   $game_temp.battle_turn = 0
   $game_temp.battle_event_flags.clear
   $game_temp.battle_abort = false
   $game_temp.battle_main_phase = false
   $game_temp.battleback_name = $game_map.battleback_name
   $game_temp.forcing_battler = nil
   #
   $game_system.battle_interpreter.setup(nil, 0)
   # ?
   @troop_id = $game_temp.battle_troop_id
   $game_troop.setup(@troop_id)
   # ?
   s1 = $data_system.words.attack
   s2 = $data_system.words.skill
   s3 = $data_system.words.guard
   s4 = $data_system.words.item
   @actor_command_window = Window_Command.new(640, [s1, s2, s3, s4], 4)
   @actor_command_window.y = 64
   @actor_command_window.back_opacity = 160
   @actor_command_window.active = false
   @actor_command_window.visible = false
   #
   @party_command_window = Window_PartyCommand.new
   @help_window = Window_Help.new
   @help_window.back_opacity = 160
   @help_window.visible = false
   #@status_window = Window_BattleStatus.new
   @message_window = Window_Message.new
   # ??
   @spriteset = Spriteset_Battle.new
   #
   @wait_count = 0
   #
   if $data_system.battle_transition == ""
     Graphics.transition(20)
   else
     Graphics.transition(40, "Graphics/Transitions/" +
       $data_system.battle_transition)
   end
   # ??
   start_phase1
   #
   loop do
     # ??
     Graphics.update
     # ?
     Input.update
     #
     update
     # ?
     if $scene != self
       break
     end
   end
   # ?
$game_map.refresh
   #
   Graphics.freeze
   # ??
   @actor_command_window.dispose
   @party_command_window.dispose
   @help_window.dispose
   #@status_window.dispose
   @message_window.dispose
   if @skill_window != nil
     @skill_window.dispose
   end
   if @item_window != nil
     @item_window.dispose
   end
   if @result_window != nil
     @result_window.dispose
   end
   # ??
   @spriteset.dispose
   #
   if $scene.is_a?(Scene_Title)
     # ?
     Graphics.transition
     Graphics.freeze
   end
   #
   if $BTEST and not $scene.is_a?(Scene_Gameover)
     $scene = nil
   end
 end
 
 def update
   # ?
   if $game_system.battle_interpreter.running?
     #
     $game_system.battle_interpreter.update
     # ?
     if $game_temp.forcing_battler == nil
       # ??
       unless $game_system.battle_interpreter.running?
         # ??
         unless judge
           setup_battle_event
         end
       end
       # ?
       if @phase != 5
         # ??
         #@status_window.refresh
       end
     end
   end
   # ? (?)
   $game_system.update
   $game_screen.update
   # ?? 0
   if $game_system.timer_working and $game_system.timer == 0
     # ??
     $game_temp.battle_abort = true
   end
   # ??
   @help_window.update
   @party_command_window.update
   @actor_command_window.update
   #@status_window.update
   @message_window.update
   # ??
   @spriteset.update
   # ?
   if $game_temp.transition_processing
     # ??
     $game_temp.transition_processing = false
     #
     if $game_temp.transition_name == ""
       Graphics.transition(20)
     else
       Graphics.transition(40, "Graphics/Transitions/" +
         $game_temp.transition_name)
     end
   end
   # ?
   if $game_temp.message_window_showing
     return
   end
   # ??
   if @spriteset.effect?
     return
   end
   # ?
   if $game_temp.gameover
     # ??
     $scene = Scene_Gameover.new
     return
   end
   # ??
   if $game_temp.to_title
     # ??
     $scene = Scene_Title.new
     return
   end
   # ??
   if $game_temp.battle_abort
     # ? BGM
     $game_system.bgm_play($game_temp.map_bgm)
     # ??
     battle_end(1)
     return
   end
   # ??
   if @wait_count > 0
     #
     @wait_count -= 1
     return
   end
   
   # this one holds the battle while the player moves
   for actor in @spriteset.actor_sprites
     if actor.moving
       return
     end
   end
   # and this one is for the enemy...
   for enemy in @spriteset.enemy_sprites
     if enemy.moving# and $game_system.animated_enemy
       return
     end
   end
   # ??
   # ?
   if $game_temp.forcing_battler == nil and
      $game_system.battle_interpreter.running?
     return
   end
   # ?
   case @phase
   when 1  #
     update_phase1
   when 2  #
     update_phase2
   when 3  #
     update_phase3
   when 4  # ?
     update_phase4
   when 5  # ??
     update_phase5
   end
 end
 
 def start_phase2
   # ? 2
   @phase = 2
   # ?
   @actor_index = -1
   @active_battler = nil
   # ??
   @party_command_window.active = true
   @party_command_window.visible = true
   # ??
   @actor_command_window.active = false
   @actor_command_window.visible = false
   @help_window.visible = false
   # ??
   $game_temp.battle_main_phase = false
   # ?
   $game_party.clear_actions
   #
   unless $game_party.inputable?
     #
     start_phase4
   end
 end
 
 def update_phase2_escape
   # ??
   enemies_agi = 0
   enemies_number = 0
   for enemy in $game_troop.enemies
     if enemy.exist?
       enemies_agi += enemy.agi
       enemies_number += 1
     end
   end
   if enemies_number > 0
     enemies_agi /= enemies_number
   end
   # ??
   actors_agi = 0
   actors_number = 0
   for actor in $game_party.actors
     if actor.exist?
       actors_agi += actor.agi
       actors_number += 1
     end
   end
   if actors_number > 0
     actors_agi /= actors_number
   end
   #
   success = rand(100) < 50 * actors_agi / enemies_agi
   # ?
   if success
     # ?? SE
     $game_system.se_play($data_system.escape_se)
       for actor in $game_party.actors
         @spriteset.actor_sprites[actor.index].pose(2)
         @spriteset.actor_sprites[actor.index].move(660, actor.screen_y, 10)
       end
       check = escape_move
     until check == false
       @spriteset.update
       Graphics.update
       check = escape_move
     end
     # ? BGM
     $game_system.bgm_play($game_temp.map_bgm)
     # ??
     battle_end(1)
   # ?
   else
     # ?
     $game_party.clear_actions
     #
     start_phase4
   end
 end
 
 def escape_move
   for actor in @spriteset.actor_sprites
     if actor.moving
       return true
     end
   end
   return false
 end
 
 def start_phase5
   # ? 5
   @phase = 5
   # ?? ME
   $game_system.me_play($game_system.battle_end_me)
   # ? BGM
   $game_system.bgm_play($game_temp.map_bgm)
   # EXP???
   exp = 0
   gold = 0
   treasures = []
   #
   for enemy in $game_troop.enemies
     # ??
     unless enemy.hidden
       # ?? EXP??
       exp += enemy.exp
       gold += enemy.gold
       #
       if rand(100) < enemy.treasure_prob
         if enemy.item_id > 0
           treasures.push($data_items[enemy.item_id])
         end
         if enemy.weapon_id > 0
           treasures.push($data_weapons[enemy.weapon_id])
         end
         if enemy.armor_id > 0
           treasures.push($data_armors[enemy.armor_id])
         end
       end
     end
   end
   # ?? 6
   treasures = treasures[0..5]
   # EXP ??
   for i in 0...$game_party.actors.size
     actor = $game_party.actors
     if actor.cant_get_exp? == false
       last_level = actor.level
       actor.exp += exp
       if actor.level > last_level
         #@status_window.level_up(i)
       end
     end
   end
   #
   $game_party.gain_gold(gold)
   # ?
   for item in treasures
     case item
     when RPG::Item
       $game_party.gain_item(item.id, 1)
     when RPG::Weapon
       $game_party.gain_weapon(item.id, 1)
     when RPG::Armor
       $game_party.gain_armor(item.id, 1)
     end
   end
   #
   @result_window = Window_BattleResult.new(exp, gold, treasures)
   # ??
   @phase5_wait_count = 100
 end
 
 #--------------------------------------------------------------------------
 # ? (??)
 #--------------------------------------------------------------------------
 def update_phase5
   # 0 ?
   if @phase5_wait_count > 0
     #
     @pha

Oh my goodness!  Put code tags around that - quickly!

it looks like this:
<code>
your code goes here
</code>

except you use [ and ] instead of < and >

Do that one more time and it's a strike for you.

Wrapped this up in a spoiler for the sake of others sanity.

EDIT: So that's why it didn't work for him. The forum cut off his post.