View difference between Paste ID: VRyZf09m and LherAyWS

 #===============================================================================
 # ** RBS - Ramiro's Battle System (PART II - Classes And Modules)
 # Version 2.2
 # Difficulty Very Hard.
-# + little shield Addon by Stesc
+# + small Shield Addon by Stesc
 #-------------------------------------------------------------------------------
 # If you don't know what to do... DO NOT EDIT THIS FILE.
 #-------------------------------------------------------------------------------
 # YANFLY SCRIPTS COMPATIBILITY:
 #
 # Common ways to test if an YF script works:
 #
 # First of all, put the Unlisted YEA script BEFORE the RBS, why before? because
 # YEA is 'older' (in terms of published date) and the compatibility patches are
 # made with the RBS (that supports a way to mix both battle systems altogether)
 #
 # If the script does not work properly, you may put it AFTER RBS and TRY AGAIN.
 #
 # If even with that change the script does not work, you may then call it a
 # "compatibility issue" and I will, eventually, make a patch for it.
 #
 # Why are you making compatibility patches?
 #
 # It's quite simple, YF scripts sometimes overrite some methods that I had to
 # alias or vice-versa. in that cases, Yanfly or I should need to make a Patch.
 # To run the scripts toguether.
 #
 # The next section will show HOW TO APPLY each script, knowkn in wich order
 # and if it needs or not this patch.
 #
 #
 #
 # List of Compatible YEA scripts:
 # BATTLE SCRIPTS:
 #  - Ace Battle Engine (Insert BEFORE RBS)
 #           Known Issues: Disable one of the popup systems or YEA popup or
 #                         RBS popup.
 #  - Lunatic Objects (Doesn't infleunce the place)
 #           Known Issues: None.
 #  - TargetManager (Doesn't infleunce the place)
 #           Known Issues: None.
 #  - CastAnimations (Doesn't infleunce the place)
 #           Known Issues: None.
 #
 # OTHER YF SCRIPTS:
 # Because other YF scripts won't collide with this battle system.
 # They should be compatible. If there is an incompatibility issue, just
 # ask and I'll do as much as I can to repair it.
 #-------------------------------------------------------------------------------
 # License:
 #Copyright (c) 2012, Ramiro Rojo
 #All rights reserved.
 #
 #Redistribution and use in source and binary forms, with or without
 #modification, are permitted provided that the following conditions are met:
 #
 #1. Redistributions of source code must retain the above copyright notice, this
 #   list of conditions and the following disclaimer.
 #2. Redistributions in binary form must reproduce the above copyright notice,
 #   this list of conditions and the following disclaimer in the documentation
 #   and/or other materials provided with the distribution.
 #
 #THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 #ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 #WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 #DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 #ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 #(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 #LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 #ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 #(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 #SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 #The views and conclusions contained in the software and documentation are those
 #of the authors and should not be interpreted as representing official policies,
 #either expressed or implied, of the FreeBSD Project.
 #===============================================================================
 
 #===============================================================================
 # BEGIN MODULE SECTION
 #===============================================================================
 
 module Cache
 
   #-----------------------------------------------------------------------------
   # Constants
   #-----------------------------------------------------------------------------
   @@icon_bitmaps = {}
 
   def self.get_icon_bitmap(icon_index)
     if !@@icon_bitmaps[icon_index] || @@icon_bitmaps[icon_index].disposed?
       bmp = Bitmap.new(24,24)
       bitmap = Cache.system("Iconset")
       rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
       bmp.blt(0, 0, bitmap, rect)
       @@icon_bitmaps[icon_index] = bmp
     end
     @@icon_bitmaps[icon_index]
   end
 
   class << self
     alias rbs_cache_clear clear
 
     def clear
       @@icon_bitmaps ||= {}
       @@icon_bitmaps.clear
       rbs_cache_clear
     end
   end
 
 end
 
 #===============================================================================
 # * BattleCamera module
 #-------------------------------------------------------------------------------
 # Controls the camera`s position on the battlefield.
 # It can be zoomed in and out.
 #===============================================================================
 module BattleCamera
 
   #-----------------------------------------------------------------------------
   # Starts the camera
   #-----------------------------------------------------------------------------
   def self.start
     self.reset
   end
 
   #-----------------------------------------------------------------------------
   # Resets the camera
   #-----------------------------------------------------------------------------
   def self.reset
     @center_x = Graphics.width  / 2
     @center_y = Graphics.height / 2
     @current_x = @desired_x = @center_x
     @current_y = @desired_y = @center_y
     @current_zoom = @desired_zoom = 1.0
     @zoom_time = 0
     @movement_time = 0
     @target = :screen
   end
 
   #-----------------------------------------------------------------------------
   # Corrects a position
   #-----------------------------------------------------------------------------
   def self.correct_position(pos, current, current_zoom, center)
     return ((pos - current) * (current_zoom - 1.0) + pos - (current - center))
   end
 
   #-----------------------------------------------------------------------------
   # Corrects the x position given
   #-----------------------------------------------------------------------------
   def self.correct_x(x)
     return correct_position(x, @current_x, @current_zoom, @center_x)
   end
 
   #-----------------------------------------------------------------------------
   # Corrects the y position given
   #-----------------------------------------------------------------------------
   def self.correct_y(y)
     return correct_position(y, @current_y, @current_zoom, @center_y)
   end
 
   #-----------------------------------------------------------------------------
   # Corrects the zoom given
   #-----------------------------------------------------------------------------
   def self.correct_zoom(zoom, x=nil, y=nil, zoom_effective=true)
     if BattleConfig::BattleCamera_UsePanoramicCamera
       if !x || !y || !zoom_effective
         return zoom * @current_zoom
       else
         return ((y - @center_y * 130 / 100) * 0.005 + 1.0) * @current_zoom
       end
     else
       return zoom * @current_zoom
     end
   end
 
   #-----------------------------------------------------------------------------
   # Corrects the angle given
   #-----------------------------------------------------------------------------
   def self.correct_angle(angle)
     return angle
   end
 
   #-----------------------------------------------------------------------------
   # Corrects the mirror value given
   #-----------------------------------------------------------------------------
   def self.correct_mirror(mirror)
     return mirror
   end
 
   #-----------------------------------------------------------------------------
   # Calculates the difference of movement in the frame
   #-----------------------------------------------------------------------------
   def self.calculate_display_change(current, desired, count)
     ((current * (count - 1) + desired) / count)
   end
 
   #-----------------------------------------------------------------------------
   # Updates the camera.
   #-----------------------------------------------------------------------------
   def self.update
     @center_x = Graphics.width  / 2
     @center_y = Graphics.height / 2
     if @zoom_time > 0
       @current_zoom = self.calculate_display_change(@current_zoom, @desired_zoom, @zoom_time)
       @zoom_time -= 1
     end
 
     if @movement_time > 0
       @current_x = self.calculate_display_change(@current_x, @desired_x, @movement_time)
       @current_y = self.calculate_display_change(@current_y, @desired_y, @movement_time)
       @movement_time -= 1
     end
 
     if @target != :screen && !moving?
       cx = 0
       cy = 0
       @target.each do |i|
         cx += i.current_x
         cy += i.current_y
       end
       if @target.size > 0
         cx /= @target.size
         cy /= @target.size
       end
       @current_x = cx
       @current_y = cy
     end
 
   end
 
   #-----------------------------------------------------------------------------
   # Sets the movement of the Camera.
   #-----------------------------------------------------------------------------
   def self.set_movement(x, y, time)
     @desired_x = x
     @desired_y = y
     @movement_time = time
   end
 
   #-----------------------------------------------------------------------------
   # Sets the zoom of the Camera.
   #-----------------------------------------------------------------------------
   def self.set_zoom(zoom, time)
     @desired_zoom = zoom
     @zoom_time = time
   end
 
   #-----------------------------------------------------------------------------
   # Sets the target of the Camera.
   #-----------------------------------------------------------------------------
   def self.set_target(target)
     @target = target
   end
 
   #-----------------------------------------------------------------------------
   # Checks if the camera is moving.
   #-----------------------------------------------------------------------------
   def self.moving?
     return ( @movement_time > 0 || @zoom_time > 0 )
   end
 
 end
 
 #===============================================================================
 # * BattleInterpreter module
 #-------------------------------------------------------------------------------
 # This module manages the battle's actions and keeps track of all of them.
 # it can read commands for using in battle animations.
 #===============================================================================
 module BattleInterpreter
 
   #-----------------------------------------------------------------------------
   # CONSTANTS
   #-----------------------------------------------------------------------------
   Commands = {}
 
   #=============================================================================
   # * BattleInterpreter::Action
   #-----------------------------------------------------------------------------
   # An action used by the battle interpreter module.
   # It stores information of the action used and process part of them.
   #=============================================================================
   class Action
 
     #---------------------------------------------------------------------------
     # Class properties
     #---------------------------------------------------------------------------
     attr_reader   :original_user
     attr_reader   :original_target
     attr_accessor :user
     attr_accessor :targets
     attr_accessor :item
     attr_accessor :loop_depth
     attr_accessor :linked_actions
     attr_accessor :paused
 
     #---------------------------------------------------------------------------
     # Starts an action
     #---------------------------------------------------------------------------
     def initialize(spriteset, user, targets, sequence, item, can_counter=true)
       @extra_affected_battlers = []
       @sequence = sequence
       @user = user
       @targets = targets
       @item = item
       @loop_depth = 0
       @wait_count = 0
       @original_user = user
       @original_targets = targets
       @spriteset = spriteset
       @counter_check = can_counter
       @linked_actions = []
       @paused = false
       compile_data
     end
 
     #---------------------------------------------------------------------------
     # Checks if a counter can be realized
     #---------------------------------------------------------------------------
     def counter_active?
       return @counter_check
     end
 
     #---------------------------------------------------------------------------
     # Evaluates parameters
     #---------------------------------------------------------------------------
     def eval_data(data)
       make_parameters(data)[0]
     end
 
     #---------------------------------------------------------------------------
     # Sets the wait time of the action
     #---------------------------------------------------------------------------
     def wait(wait)
       @wait_count = wait
     end
 
     #---------------------------------------------------------------------------
     # Makes the parameters for an action
     #---------------------------------------------------------------------------
     def make_parameters(parameters)
       return [] if !parameters
       a = @user
       b = @targets[0]
       t = @targets
       s = $game_siwtches
       v = $game_variables
       result = []
       parameters.split(',').each do |i|
         r = Kernel.eval(i) rescue nil
         result.push(r)
       end
       return result
     end
 
     #---------------------------------------------------------------------------
     # Compiles the data for the action
     #---------------------------------------------------------------------------
     def compile_data
       @commands = get_compile_commands(@sequence)
     end
 
     #---------------------------------------------------------------------------
     # Returns the compiled result
     #---------------------------------------------------------------------------
     def get_compile_commands(data)
       result = []
       data.split(';').each do |line|
         next if (line.gsub(/\s/mi) {''}) == ''
         line += ';'
         if line[/((\s+)?)(.*?)(:(.*?))?;/mi]
           result.push([$3.upcase, make_parameters($5)])
         end
       end
       return result
     end
 
     #---------------------------------------------------------------------------
     # Updates the action
     #---------------------------------------------------------------------------
     def update
       return if @paused
       if (@wait_count && @wait_count > 0)
         @wait_count -= 1
         return
       end
       call_next_command
     end
 
     #---------------------------------------------------------------------------
     # Calls next command
     #---------------------------------------------------------------------------
     def call_next_command
       return if @commands.size == 0 || (@wait_count && @wait_count > 0)
       initial_depth = current_depth = @loop_depth
       command, params = next_command
       raise sprintf(Vocab::Error_CommandNotRecognized, command) if !Commands[command]
       has_depth, link_method = Commands[command]
       current_depth += 1
       result = []
       if has_depth
         while initial_depth != current_depth && @commands.size > 0
           i = next_command
           nested_command, nested_params = i
           if Commands[nested_command] && Commands[nested_command][0]
             current_depth += 1
           elsif nested_command[/END/mi]
             current_depth -= 1
           end
           result.push(i)
         end
         if initial_depth == current_depth
           params.push(result)
           @loop_depth += 1
         else
           raise Vocab::Error_TagSintaxError
         end
       end
       link_method.call(self, params)
       call_next_command
     end
 
     #---------------------------------------------------------------------------
     # Gets the next command
     #---------------------------------------------------------------------------
     def next_command
       @commands.shift
     end
 
     #---------------------------------------------------------------------------
     # Insert commands as next
     #---------------------------------------------------------------------------
     def insert_commands_as_next(commands)
       @commands = commands + @commands
     end
 
     #---------------------------------------------------------------------------
     # Checks if the action is running
     #---------------------------------------------------------------------------
     def running?
       return (@commands.size > 0 || @wait_count > 0)
     end
 
     #---------------------------------------------------------------------------
     # Pauses the action
     #---------------------------------------------------------------------------
     def pause
       @paused = true
     end
 
     #---------------------------------------------------------------------------
     # Checks if the action is paused
     #---------------------------------------------------------------------------
     def paused?
       @paused
     end
 
     #---------------------------------------------------------------------------
     # Resumes the action
     #---------------------------------------------------------------------------
     def resume
       @paused = false
       call_next_command
     end
 
     #---------------------------------------------------------------------------
     # Stops the action
     #---------------------------------------------------------------------------
     def abort
       @commands.clear
       @wait_count = 0
     end
 
     #---------------------------------------------------------------------------
     # Analizes targets by a string
     #---------------------------------------------------------------------------
     def analize_target_string(string, origin_valid = true, screen_valid = false)
       case string
       when /(.*?) except (.*)/im
         t1 = analize_target_string($1, origin_valid, screen_valid)
         t2 = analize_target_string($2, origin_valid, screen_valid)
         return t1 - t2
       when /(.*?) but (.*)/im
         t1 = analize_target_string($1, origin_valid, screen_valid)
         t2 = analize_target_string($2, origin_valid, screen_valid)
         return t1 - t2
       when /(\d+) random ([\w\s]+)/im
         num = $1.to_i
         targets = analize_target_string($2, false, false)
         result = []
         num.times do |i|
           result.push(targets[rand(targets.size)])
         end
         return result
       when /original (\w+)/im
         case $1
         when /user/im
           return [@original_user]
         when /target(s?)/im
           return @original_targets
         end
       when /dead battler(s?)/im
           return $game_troop.dead_members + $game_party.dead_members
       when /dead all(y||es)/im
         case @user.confusion_level
         when 0
           return @user.friend_unit.dead_members
         when 1
           return @user.enemy_unit.dead_members+@user.friend_unit.dead_members
         when 2
           return @user.enemy_unit.dead_members
         end
       when /dead enem(y||ies)/im
         case @user.confusion_level
         when 0
           return @user.enemy_unit.dead_members
         when 1
           return @user.enemy_unit.dead_members+@user.friend_unit.dead_members
         when 2
           return @user.friend_unit.dead_members
         end
       when /battler(s?)/im
           return $game_troop.alive_members + $game_party.alive_members
       when /all(y||es)/im
         case @user.confusion_level
         when 0
           return @user.friend_unit.alive_members
         when 1
           return @user.enemy_unit.alive_members+@user.friend_unit.alive_members
         when 2
           return @user.enemy_unit.alive_members
         end
       when /friend(s?)/im
         case @user.confusion_level
         when 0
           group = @user.friend_unit.alive_members
         when 1
           group = @user.enemy_unit.alive_members+@user.friend_unit.alive_members
         when 2
           group = @user.enemy_unit.alive_members
         end
         return group - [@user]
       when /enem(y||ies)/im
         case @user.confusion_level
         when 0
           return @user.enemy_unit.alive_members
         when 1
           return @user.enemy_unit.alive_members+@user.friend_unit.alive_members
         when 2
           return @user.friend_unit.alive_members
         end
       when /target(s?)/im
         return @targets
       when /user/im
         return [@user]
       when /screen/im
         if screen_valid
           return :screen
         else
           raise Vocab::Error_ScreenNotValid
         end
       when /origin/im
         if origin_valid
           return :origin
         else
           raise Vocab::Error_OriginNotValid
         end
       end
       return nil
 
     end
 
     #---------------------------------------------------------------------------
     # Get the sprites of battlers.
     #---------------------------------------------------------------------------
     def get_battler_sprites(battlers)
       result = []
       @spriteset.battler_sprites.each do |i|
         result.push(i) if battlers.any? {|j| i.battler == j }
       end
       return result
     end
 
     #---------------------------------------------------------------------------
     # gets the battler sprites of a determined target string
     #---------------------------------------------------------------------------
     def analize_battler_sprites_string(string, origin_valid = true, screen_valid = false)
       battlers = analize_target_string(string, origin_valid, screen_valid)
       return battlers if battlers.is_a?(Symbol)
       return battlers ? get_battler_sprites(battlers) : []
     end
 
     def affected_battlers
       targets + [user] + @extra_affected_battlers
     end
 
   end
 
   class LoopingAction < BattleInterpreter::Action
 
     def next_command
       new_command = @commands.shift
       @commands.push(new_command)
       return new_command
     end
 
   end
 
   #-----------------------------------------------------------------------------
   # Starts the interpreter
   #-----------------------------------------------------------------------------
   def self.start(spriteset)
     self.reset
     @spriteset = spriteset
   end
 
   #-----------------------------------------------------------------------------
   # Resets the interpreter
   #-----------------------------------------------------------------------------
   def self.reset
     Commands.clear
     @looping_actions = {}
     @actions = []
   end
 
   #-----------------------------------------------------------------------------
   # Adds an action
   #-----------------------------------------------------------------------------
   def self.add_action(user, targets, sequence, item, can_counter = true)
     action = BattleInterpreter::Action.new(@spriteset, user, targets, sequence, item, can_counter)
     @actions.push(action) if @actions
     action
   end
 
   #-----------------------------------------------------------------------------
   # Updates the interpreter
   #-----------------------------------------------------------------------------
   def self.update
     current_battlers = []
     @actions.each do |i|
       i.update
       if i.running?
         i.affected_battlers.each do |j|
           current_battlers.push(j)
         end
       else
         @actions.delete(i)
       end
     end
     @looping_actions.each_pair do |battler, action|
       action.update if !current_battlers.include?(battler)
     end
   end
 
   #-----------------------------------------------------------------------------
   # Checks if the interpreter is running
   #-----------------------------------------------------------------------------
   def self.running?
     return true if @actions.any? {|i| i.running? && !i.paused?}
     return true if BattleCamera.moving?
     return true if @spriteset.animation?
     return false
   end
 
   #-----------------------------------------------------------------------------
   # Adds a looping action to an user
   #-----------------------------------------------------------------------------
   def self.add_looping_action(user, sequence)
     action = BattleInterpreter::LoopingAction.new(@spriteset, user, [user], sequence, nil)
     @looping_actions[user] = action
     action
   end
 
   def self.pause_looping_action(user)
     @looping_actions[user].pause if @looping_actions[user]
   end
 
   def self.resume_looping_action(user)
     @looping_actions[user].resume if @looping_actions[user]
   end
 
 end
 
 #==============================================================================
 # ¦ BattleManager
 #==============================================================================
 
 module BattleManager
 
   #-----------------------------------------------------------------------------
   # Checks if the battle is a surprise battle
   #-----------------------------------------------------------------------------
   def self.surprise?
     return @surprise
   end
 
   #-----------------------------------------------------------------------------
   # Checks if the battle is a preemptive battle
   #-----------------------------------------------------------------------------
   def self.preemptive?
     return @preemptive
   end
 
   class << self
 
     #---------------------------------------------------------------------------
     # Alias methods
     #---------------------------------------------------------------------------
     alias rbs_battle_manager_process_victory process_victory
 
     #-----------------------------------------------------------------------------
     # Process victory
     #-----------------------------------------------------------------------------
     def process_victory
       for member in $game_party.alive_members
         sequence = member.get_victory_sequence
         BattleInterpreter.add_action(member, [member], sequence, nil, false)
       end
       rbs_battle_manager_process_victory
     end
   end
 
 end
 #===============================================================================
 # END MODULE SECTION
 #===============================================================================
 #===============================================================================
 # BEGIN SPRITE SECTION
 #===============================================================================
 
 #===============================================================================
 # ¦ Sprite_Battler
 #===============================================================================
 class Sprite_Battler < Sprite_Base
 
   #-----------------------------------------------------------------------------
   # Alias methods
   #-----------------------------------------------------------------------------
   alias rbs_sprite_battler_initialize initialize
   alias rbs_sprite_battler_update update
   alias rbs_sprite_battler_animation? animation?
   alias rbs_sprite_battler_dispose dispose
 
   #-----------------------------------------------------------------------------
   # Class Properties
   #-----------------------------------------------------------------------------
   attr_reader :current_x
   attr_reader :current_y
   attr_reader :original_x
   attr_reader :original_y
 
   #-----------------------------------------------------------------------------
   # Resets the position.
   #-----------------------------------------------------------------------------
   def reset_position
     @character_started = true
     @original_battler = @battler
     @original_x = @battler.screen_x
     @original_y = @battler.screen_y
     @current_x = @desired_x = @original_x
     @current_y = @desired_y = @original_y
     @jump_count = 0
     @jump_axis  = 0
     @jump_value = 0
     @movement_count = 0
     @frame_count = 0
     @frame_delay = 16
     @last_battler = battler
     @battler_index = @battler.default_battler_index
     @frame = 0
     @pose  = 0
     @poses = 1
     @frames = 1
     @frame_style = :rmvx
     @loops = 0
     @last_battle_index = 0
     @desired_zoom_x = @current_zoom_x = 1
     @desired_zoom_y = @current_zoom_y = 1
     @current_angle = @desired_angle = 0
     @angle_time = 0
     @zoom_time = 0
     @current_opacity = @desired_opacity = 0
     @opacity_time = 0
     @battler_name_result = ''
     @mirrored_sprite = false
     @effect_opacity = 255
     @effect_ox  = 0
     @effect_height = 0
     @balloon_id = 0
     @need_refresh = true
     @last_battler = nil
     @last_battler_name = ''
     @last_battler_hue = 0
   end
 
   def make_return_sequence(include_stand=true)
     return if !@battler
     seq = ''
     if (@original_x != @current_x) || (@original_y != @current_y)
       seq = @battler.get_return_sequence
     end
     BattleInterpreter.add_action(@battler, [@battler], seq, nil, false)
     if @battler.alive? && include_stand
       BattleInterpreter.add_looping_action(@battler, @battler.get_stand_sequence)
     end
   end
 
   #-----------------------------------------------------------------------------
   # Sets the mirror value
   #-----------------------------------------------------------------------------
   def set_mirror_value(value)
     @mirrored_sprite = value
   end
 
   #-----------------------------------------------------------------------------
   # Creates the sprite
   #-----------------------------------------------------------------------------
   def initialize(viewport, battler=nil)
     @weapon_sprites = []
     @character_started = false
     @afterimages = []
     @afterimages_visible = false
     @afterimage_separation = 8
     @animation_reg = []
     rbs_sprite_battler_initialize(viewport, battler)
   end
 
   #-----------------------------------------------------------------------------
   # Dispose
   #-----------------------------------------------------------------------------
   def dispose
     dispose_afterimages
     dispose_weapon_sprites
     dispose_balloon
     rbs_sprite_battler_dispose
   end
 
   #-----------------------------------------------------------------------------
   # Dispose afterimages
   #-----------------------------------------------------------------------------
   def dispose_afterimages
     @afterimages.each do |i|
       i.dispose
     end
     @afterimages.clear
   end
 
   #-----------------------------------------------------------------------------
   # Dispose weapon sprites
   #-----------------------------------------------------------------------------
   def dispose_weapon_sprites
     @weapon_sprites.each do |i|
       i.dispose
     end
   end
 
   #-----------------------------------------------------------------------------
   # Checks if the sprite is moving?
   #-----------------------------------------------------------------------------
   def moving?
     return false if !@battler
     return (@movement_count > 0 || @angle_time > 0 || @zoom_time > 0 || @opacity_time > 0 )
   end
 
   #--------------------------------------------------------------------------
   # ? Update blink effect
   #--------------------------------------------------------------------------
   def update_blink
     @effect_opacity = (@effect_duration % 10 < 5) ? 255 : 0
   end
   #--------------------------------------------------------------------------
   # ? Opdates appear effect
   #--------------------------------------------------------------------------
   def update_appear
     @effect_opacity = (16 - @effect_duration) * 16
   end
   #--------------------------------------------------------------------------
   # ? Opdates disappear effect
   #--------------------------------------------------------------------------
   def update_disappear
     @effect_opacity = 256 - (32 - @effect_duration) * 10
   end
   #--------------------------------------------------------------------------
   # ? Update collapse effect
   #--------------------------------------------------------------------------
   def update_collapse
     self.blend_type = 1
     self.color.set(255, 128, 128, 128)
     @effect_opacity = 256 - (48 - @effect_duration) * 6
   end
 
   #--------------------------------------------------------------------------
   # ? Reverts the sprite to normal
   #--------------------------------------------------------------------------
   def revert_to_normal
     self.blend_type = 0
     self.color.set(0, 0, 0, 0)
     @effect_opacity = 255
     @effect_ox = @battler_width / 2 if bitmap
     @effect_height = 0
   end
 
   #--------------------------------------------------------------------------
   # ? Updates boss collpase
   #--------------------------------------------------------------------------
   def update_boss_collapse
     alpha = @effect_duration * 120 / bitmap.height
     @effect_ox = @battler_width / 2 + @effect_duration % 2 * 4 - 2
     self.blend_type = 1
     self.color.set(255, 255, 255, 255 - alpha)
     @effect_opacity = alpha
     @effect_height -= 1
     Sound.play_boss_collapse2 if @effect_duration % 20 == 19
   end
   #--------------------------------------------------------------------------
   # ?  updates instant collapse
   #--------------------------------------------------------------------------
   def update_instant_collapse
     @effect_opacity = 0
   end
 
   #-----------------------------------------------------------------------------
   # Frame update
   #-----------------------------------------------------------------------------
   def update
     if @battler && (!@character_started || @battler != @original_battler)
       start = @character_started
       reset_position
       if start
         @current_opacity = @desired_opacity = 255
         start_effect(:appear)
         update
         make_return_sequence
       end
     elsif !@battler && @original_battler
       @original_battler = nil
     end
     set_animation_origin if @animation
     rbs_sprite_battler_update
     if @battler
       update_battler_position
       update_battler_pose
       update_afterimages
       update_weapon_sprites
       update_balloon
     end
 
   end
 
   #-----------------------------------------------------------------------------
   # Update positions.
   #-----------------------------------------------------------------------------
   def update_battler_position
     if @movement_count > 0
       @current_x = BattleCamera.calculate_display_change(@current_x, @desired_x, @movement_count)
       @current_y = BattleCamera.calculate_display_change(@current_y, @desired_y, @movement_count)
       if @jump_count > 0
         @jump_value = BattleCamera.calculate_display_change(@jump_value, @jump_axis, @jump_count)
         @jump_count -= 1
       elsif @jump_value != 0
         @jump_axis = 0
         @jump_count = @movement_count - 1
       end
       @movement_count -= 1
     end
 
     if @zoom_time > 0
       @current_zoom_x = BattleCamera.calculate_display_change(@current_zoom_x, @desired_zoom_x, @zoom_time)
       @current_zoom_y = BattleCamera.calculate_display_change(@current_zoom_y, @desired_zoom_y, @zoom_time)
       @zoom_time -= 1
     end
 
     if @angle_time > 0
       @current_angle = BattleCamera.calculate_display_change(@current_angle, @desired_angle, @angle_time)
       @angle_time -= 1
     end
 
     if @opacity_time > 0
        @current_opacity = BattleCamera.calculate_display_change(@current_opacity, @desired_opacity, @opacity_time)
        @opacity_time -= 1
     end
 
     @original_x = @battler.screen_x
     @original_y = @battler.screen_y
 
     self.x = BattleCamera.correct_x( @current_x )
     self.y = BattleCamera.correct_y( @current_y - @jump_value - @effect_height / 2)
     self.z = @current_y + 100
     self.zoom_x = BattleCamera.correct_zoom(@current_zoom_x, @current_x, @current_y, @battler.zoom_effective?)
     self.zoom_y = BattleCamera.correct_zoom(@current_zoom_y, @current_x, @current_y, @battler.zoom_effective?)
     self.angle =  BattleCamera.correct_angle(@current_angle)
     self.mirror = BattleCamera.correct_mirror(@battler.enemy? ? @mirrored_sprite : !@mirrored_sprite)
     self.opacity = @current_opacity * @effect_opacity / 255
     self.visible = @effect_type || @battler.exist?
   end
 
   #-----------------------------------------------------------------------------
   # Get the max frame number
   #-----------------------------------------------------------------------------
   def max_frames
     return @frame_style == -2 ? @frames * 2 : @frames
   end
 
   #-----------------------------------------------------------------------------
   # Gets the real frame number
   #-----------------------------------------------------------------------------
   def real_frame
     return @frame < @frames ? @frame : (max_frames - @frame - 1)
   end
 
   #-----------------------------------------------------------------------------
   # Updates the current pose
   #-----------------------------------------------------------------------------
   def update_battler_pose
 
     if @loops != 0
       if @frame_style < 0
         @frame_count = (@frame_count + 1) % @frame_delay
         if @frame_count == 0
           @frame = (@frame + 1) % max_frames
           @loops -= 1 if  @frame == 0 && @loops > 0
         end
       else
         @frame = @frame_style
       end
     end
     o_x = @battler_width  * real_frame
     o_y = @battler_height * @pose + @effect_height
     bh  = [@battler_height + @effect_height, 1].max
     self.src_rect.set(o_x, o_y, @battler_width, bh)
   end
 
   #-----------------------------------------------------------------------------
   # Makes the new battler name
   #-----------------------------------------------------------------------------
   def make_battler_name
     if @need_refresh || @last_battler != self.battler ||
           @last_battler_name != battler.battler_name ||
           @last_battler_hue != battler.battler_hue
       @last_battler_name = battler.battler_name
       @last_battler_hue = battler.battler_hue
       @need_refresh = false
       @last_battler = self.battler
       battler_name = @battler.battler_name.sub(/\[(\d+),(\d+)\]/i) { '' }
       battler_name = @battler_index == 0 ? @battler.battler_name : "#{@battler.battler_name}_#{@battler_index}"
       files = Dir.glob("Graphics/Battlers/#{battler_name}*")
       @battler_name_result = (files.size > 0) ? files[0] : battler_name
       @battler_name_result.gsub! (/Graphics\/Battlers\//mi) {''}
     end
     return @battler_name_result
   end
 
   #-----------------------------------------------------------------------------
   # Updates the bitmap
   #-----------------------------------------------------------------------------
   def update_bitmap
     battler_name = make_battler_name
     new_bitmap = Cache.battler(battler_name, @battler.battler_hue)
     if self.bitmap != new_bitmap
       data = []
       if battler_name[/\[(.*?),(.*?)\]/i]
         @frames = eval($1)
         @poses  = eval($2)
       else
         @poses = BattleConfig::DefaultPoses
         @frames = BattleConfig::DefaultFrames
       end
       @frame_delay = 16
       @frame_style = -2
       @loops = -1
       self.bitmap = new_bitmap
       @battler_width  = self.bitmap.width  / @frames
       @battler_height = self.bitmap.height / @poses
       @effect_ox = @battler_width / 2 if bitmap
       init_visibility
     end
   end
 
   #-----------------------------------------------------------------------------
   # Updates the weapon sprites
   #-----------------------------------------------------------------------------
   def update_weapon_sprites
     @weapon_sprites.each do |i|
       if i.animation?
         i.update
       else
         i.dispose
         @weapon_sprites.delete(i)
       end
     end
   end
 
   #-----------------------------------------------------------------------------
   # Updates original position.
   #-----------------------------------------------------------------------------
   def update_origin
     if bitmap
       self.ox = @effect_ox
       self.oy = @battler_height + @effect_height
     end
   end
   #-----------------------------------------------------------------------------
   # Sets the movememnt
   #-----------------------------------------------------------------------------
   def set_movement(x, y, jump, time)
     @desired_x = x
     @desired_y = y
     @jump_count = time / 2
     @jump_axis  = jump
     @jump_value = 0
     @movement_count = time
   end
   #-----------------------------------------------------------------------------
   # Sets the pose
   #-----------------------------------------------------------------------------
   def set_pose(character_index, pose, style, loops, interval)
     @poses = 0 if !@poses
     @battler_index = character_index
     @frame = 0
     @frame_delay = interval
     @pose  = pose if pose < @poses
     @frame_style = style
     @loops = loops
     @need_refresh = true
   end
   #-----------------------------------------------------------------------------
   # Sets the zoom
   #-----------------------------------------------------------------------------
   def set_zoom(x, y, time)
     @desired_zoom_x = x
     @desired_zoom_y = y
     @zoom_time = time
   end
 
   #-----------------------------------------------------------------------------
   # Sets the angle
   #-----------------------------------------------------------------------------
   def set_angle(angle, time)
     @desired_angle = angle
     @angle_time = time
   end
 
   #-----------------------------------------------------------------------------
   # Sets the opacity
   #-----------------------------------------------------------------------------
   def set_opacity(opacity, time)
     @desired_opacity = opacity
     @opacity_time = time
   end
 
   #-----------------------------------------------------------------------------
   # Checks if the sprite is on animation
   #-----------------------------------------------------------------------------
   def animation?
     return rbs_sprite_battler_animation? || moving? || (@effect_duration > 0)
   end
 
   #--------------------------------------------------------------------------
   # ? Starts new effect
   #--------------------------------------------------------------------------
   def start_effect(effect_type)
     @effect_type = effect_type
     case @effect_type
     when :appear
       @effect_duration = 16
       @battler_visible = true
     when :disappear
       @effect_duration = 32
       @battler_visible = false
     when :whiten
       @effect_duration = 16
       @battler_visible = true
     when :blink
       @effect_duration = 20
       @battler_visible = true
     when :collapse
       @effect_duration = 48
       @battler_visible = false
     when :boss_collapse
       @effect_duration = @battler_height
       @battler_visible = false
     when :instant_collapse
       @effect_duration = 16
       @battler_visible = false
     end
     revert_to_normal
   end
 
   #-----------------------------------------------------------------------------
   # Sets the sprites of the animation
   #-----------------------------------------------------------------------------
   def animation_set_sprites(frame)
     cell_data = frame.cell_data
     @ani_sprites.each_with_index do |sprite, i|
       next unless sprite
       pattern = cell_data[i, 0]
       if !pattern || pattern < 0
         sprite.visible = false
         next
       end
       sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
       sprite.visible = true
       sprite.src_rect.set(pattern % 5 * 192,
         pattern % 100 / 5 * 192, 192, 192)
       if @ani_mirror
         sprite.x = @ani_ox - cell_data[i, 1]
         sprite.y = @ani_oy + cell_data[i, 2]
         sprite.angle = BattleCamera.correct_angle(360 - cell_data[i, 4])
         sprite.mirror =  BattleCamera.correct_mirror(cell_data[i, 5] == 0)
       else
         sprite.x = @ani_ox + cell_data[i, 1]
         sprite.y = @ani_oy + cell_data[i, 2]
         sprite.angle = BattleCamera.correct_angle(cell_data[i, 4])
         sprite.mirror = BattleCamera.correct_mirror(cell_data[i, 5] == 1)
       end
       sprite.z = self.z + 300 + i
       sprite.ox = 96
       sprite.oy = 96
       sprite.zoom_x = BattleCamera.correct_zoom(cell_data[i, 3] / 100.0, @current_x, @current_y, zoom_effective?)
       sprite.zoom_y = BattleCamera.correct_zoom(cell_data[i, 3] / 100.0, @current_x, @current_y, zoom_effective?)
       sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
       sprite.blend_type = cell_data[i, 7]
     end
   end
 
   def zoom_effective?
     return false if !@battler
     @battler.zoom_effective?
   end
 
   #-----------------------------------------------------------------------------
   # Updates the animation
   #-----------------------------------------------------------------------------
   def update_animation
     return unless @animation
     @ani_duration -= 1
     if @ani_duration % @ani_rate == 0
       if @ani_duration > 0
         frame_index = @animation.frame_max
         frame_index -= (@ani_duration + @ani_rate - 1) / @ani_rate
         animation_set_sprites(@animation.frames[frame_index])
         @animation.timings.each do |timing|
           animation_process_timing(timing) if timing.frame == frame_index
         end
       else
         end_animation
       end
     end
   end
   #-----------------------------------------------------------------------------
   # Updates afterimages
   #-----------------------------------------------------------------------------
   def update_afterimages
     @animation_reg.push([self.bitmap, @current_x, @current_y - @jump_value,
                          self.z,
                          @current_zoom_x, @current_zoom_y,
                          self.src_rect.clone, self.ox, self.oy,
                          @current_angle, self.mirror])
     @afterimages.each_with_index do |afterimage, i|
       j = @animation_reg.size - ((i + 1) * @afterimage_separation)
       reg = @animation_reg[j]
       next if !reg
       afterimage.update(i, @afterimages.size, reg, self)
     end
   end
 
   #-----------------------------------------------------------------------------
   # Sets the afterimages
   #-----------------------------------------------------------------------------
   def set_aftermages(value, count, separation)
     @afterimages_visible = value
     dispose_afterimages
     @afterimages.clear
     if @afterimages_visible
       count.times do |i|
         @afterimages.push(Sprite_Afterimage.new(viewport))
       end
     end
     @afterimage_separation = separation
   end
 
   #-----------------------------------------------------------------------------
   # Sets a weapon sprite by icons
   #-----------------------------------------------------------------------------
   def set_weapon_icon(x_corr, y_corr, start_angle, end_angle, time, left_hand=false, over=false)
     if left_hand
       if @battler.weapons[1]
         bitmap = get_equip_sprite_icon(@battler.weapons[1])
       else
         return
       end
     else
       if @battler.weapons[0]
         bitmap = get_equip_sprite_icon(@battler.weapons[0])
       else
         return
       end
     end
     sprite = Sprite_Weapon.new(self, bitmap, time, 1, 1, over, true)
     sprite.set_angles(start_angle, end_angle)
     sprite.setup_correction(x_corr, y_corr)
     @weapon_sprites.push(sprite)
   end
 
     def set_shield_icon(x_corr, y_corr, start_angle, end_angle, time, over=false)
 
 
-    bitmap = get_equip_sprite_icon(@battler.armors[0])
+    if @battler.armors[0]
         bitmap = get_equip_sprite_icon(@battler.armors[0])
       else
       return
     end
     sprite = Sprite_Weapon.new(self, bitmap, time, 1, 1, over, true)
     sprite.set_angles(start_angle, end_angle)
     sprite.setup_correction(x_corr, y_corr)
     @weapon_sprites.push(sprite)
   end
 
   def get_equip_sprite_icon(equip)
     Cache.get_icon_bitmap(equip.icon_index)
   end
 
   def set_weapon_sprite(bitmap_name, x_corr, y_corr, frames, interval, over)
     time = frames * interval + 1
     bitmap = get_weapon_bitmap_anime(bitmap_name)
     sprite = Sprite_Weapon.new(self, bitmap, time, frames, interval, over, false)
     sprite.setup_correction(x_corr, y_corr)
     @weapon_sprites.push(sprite)
   end
 
   def get_weapon_bitmap_anime(bitmap, hue=0)
     name = @battler.battler_name.sub(/\[(\d+),(\d+)\]/i) { '' }
     bitmap_name = "#{name}_#{bitmap}"
     if FileTest.exists?("Graphics/Battlers/#{bitmap_name}")
       return Cache.battler(bitmap_name, hue)
     else
       return Cache.battler(bitmap, hue)
     end
   end
 
   #--------------------------------------------------------------------------
   # ? ?????????????
   #--------------------------------------------------------------------------
   def start_balloon(balloon_id)
     dispose_balloon
     @balloon_id = balloon_id
     @balloon_duration = 8 * balloon_speed + balloon_wait
     @balloon_sprite = ::Sprite.new(viewport)
     @balloon_sprite.bitmap = Cache.system("Balloon")
     @balloon_sprite.ox = 16
     @balloon_sprite.oy = 32
     update_balloon
   end
   #--------------------------------------------------------------------------
   # ? ???????????
   #--------------------------------------------------------------------------
   def dispose_balloon
     if @balloon_sprite
       @balloon_sprite.dispose
       @balloon_sprite = nil
     end
     @balloon_id = 0
   end
   #--------------------------------------------------------------------------
   # ? ???????????
   #--------------------------------------------------------------------------
   def update_balloon
     return if @balloon_id == 0
     if @balloon_duration > 0
       @balloon_duration -= 1
       if @balloon_duration > 0
         @balloon_sprite.x = BattleCamera.correct_x(@current_x)
         @balloon_sprite.y = BattleCamera.correct_y(@current_y - @battler_height)
         @balloon_sprite.z = self.z + 200
         sx = balloon_frame_index * 32
         sy = (@balloon_id - 1) * 32
         @balloon_sprite.src_rect.set(sx, sy, 32, 32)
       else
         end_balloon
       end
     end
   end
   #--------------------------------------------------------------------------
   # ? ???????????
   #--------------------------------------------------------------------------
   def end_balloon
     dispose_balloon
     @balloon_id = 0
   end
   #--------------------------------------------------------------------------
   # ? ?????????????
   #--------------------------------------------------------------------------
   def balloon_speed
     return 8
   end
   #--------------------------------------------------------------------------
   # ? ?????????????????
   #--------------------------------------------------------------------------
   def balloon_wait
     return 12
   end
   #--------------------------------------------------------------------------
   # ? ???????????????
   #--------------------------------------------------------------------------
   def balloon_frame_index
     return 7 - [(@balloon_duration - balloon_wait) / balloon_speed, 0].max
   end
 
 end
 
 #===============================================================================
 # ¦ Sprite_Weapon
 #-------------------------------------------------------------------------------
 # The class that controls weapon animations.
 #===============================================================================
 class Sprite_Weapon < Sprite
 
   attr_reader :anime_count
 
   def initialize(sprite, bitmap, anime_count, frames=1, frame_interval=1, over=false, icon=false)
     super(sprite.viewport)
     @sprite = sprite
     @anime_count = anime_count
     @current_angle = 0
     @end_angle = 0
     @frames = frames
     @frame_interval = frame_interval
     @frame_count = 0
     @frame = 0
     @over = over
     @x_correction = @y_correction = 0
     self.bitmap = bitmap
     @bw = self.bitmap.width / @frames
     @bh = self.bitmap.height
     self.mirror = sprite.battler.enemy?
     self.ox = icon ? @bw : @bw / 2
     self.oy = @bh
     update_rect
   end
 
   def update
     super
     return if @anime_count < 1
     update_animation
     @anime_count -= 1
   end
 
   def update_animation
     update_angle
     update_frame
     update_rect
     update_coordinates
   end
 
   def update_angle
     @current_angle = (@current_angle * (@anime_count - 1) + @end_angle) / @anime_count
     self.angle = @sprite.angle + @current_angle
   end
 
   def update_frame
     @frame_count = (@frame_count + 1) % @frame_interval
     @frame = (@frame + 1) % @frames if @frame_count == 0
   end
 
   def update_rect
     self.src_rect.set(@bw * @frame, 0, @bw, @bh)
   end
 
   def animation?
     return (@anime_count > 0)
   end
 
   def update_coordinates
     self.x = BattleCamera.correct_x(@sprite.current_x + @x_correction)
     self.y = BattleCamera.correct_y(@sprite.current_y + @y_correction)
     self.z = @over ? @sprite.z + 1 : @sprite.z - 1
     self.zoom_x = @sprite.zoom_x
     self.zoom_y = @sprite.zoom_y
 
   end
 
   def set_angles(start_angle, end_angle)
     @current_angle = start_angle
     @end_angle = end_angle
   end
 
   def setup_correction(x, y)
     @x_correction = x
     @y_correction = y
   end
 
 end
 
 #===============================================================================
 # ¦ Sprite_Afterimage
 #-------------------------------------------------------------------------------
 # The class that controls afterimage processing.
 #===============================================================================
 
 class Sprite_Afterimage < Sprite
 
   #-----------------------------------------------------------------------------
   # Updates the afterimage
   #-----------------------------------------------------------------------------
   def update(index, size, data, sprite)
     super()
     self.bitmap = data[0]
     self.x = BattleCamera.correct_x(data[1])
     self.y = BattleCamera.correct_y(data[2])
     self.z = data[3]
     self.zoom_x = BattleCamera.correct_zoom(data[4], data[1], data[2], sprite.battler.zoom_effective?)
     self.zoom_y = BattleCamera.correct_zoom(data[5], data[1], data[2], sprite.battler.zoom_effective?)
     self.src_rect = data[6]
     self.ox = data[7]
     self.oy = data[8]
     self.angle = BattleCamera.correct_angle(data[9])
     self.mirror = data[10]
     self.opacity = 255 - (index * 255 / size)
   end
 
 end
 
 #==============================================================================
 # ¦ Sprite_BattlePicture
 #==============================================================================
 
 class Sprite_BattlePicture < Sprite_Base
   #--------------------------------------------------------------------------
   # ? ?????????
   #     picture : Game_Picture
   #--------------------------------------------------------------------------
   def initialize(viewport, picture)
     super(viewport)
     @picture = picture
     update
   end
   #--------------------------------------------------------------------------
   # ? ??
   #--------------------------------------------------------------------------
   def dispose
     bitmap.dispose if bitmap
     super
   end
   #--------------------------------------------------------------------------
   # ? ??????
   #--------------------------------------------------------------------------
   def update
     super
     update_bitmap
     update_origin
     update_position
     update_zoom
     update_other
   end
   #-----------------------------------------------------------------------------
   # Updates the bitmap
   #-----------------------------------------------------------------------------
   def update_bitmap
     if @picture.name.is_a?(Integer)
       self.bitmap = Cache.get_icon_bitmap(@picture.name)
     else
       self.bitmap = Cache.picture(@picture.name)
     end
   end
 
   #--------------------------------------------------------------------------
   # ? ?????
   #--------------------------------------------------------------------------
   def update_origin
     if @picture.origin == 0
       self.ox = 0
       self.oy = 0
     else
       self.ox = bitmap.width / 2
       self.oy = bitmap.height / 2
     end
   end
   #--------------------------------------------------------------------------
   # ? ?????
   #--------------------------------------------------------------------------
   def update_position
     self.x = BattleCamera.correct_x(@picture.x)
     self.y = BattleCamera.correct_y(@picture.y)
     self.z = @picture.number
   end
   #--------------------------------------------------------------------------
   # ? ??????
   #--------------------------------------------------------------------------
   def update_zoom
     self.zoom_x = BattleCamera.correct_zoom(@picture.zoom_x / 100.0)
     self.zoom_y = BattleCamera.correct_zoom(@picture.zoom_y / 100.0)
   end
   #--------------------------------------------------------------------------
   # ? ??????
   #--------------------------------------------------------------------------
   def update_other
     self.opacity = @picture.opacity
     self.blend_type = @picture.blend_type
     self.angle = @picture.angle
     self.tone.set(@picture.tone)
   end
 
   def start_animation_ex(animation, mirror = false)
     start_animation(animation, mirror)
   end
 
 
 
 end
 
 #===============================================================================
 # ¦ Spriteset_Battle
 #===============================================================================
 
 class Spriteset_Battle
 
   #--------------------------------------------------------------------------
   # ? Class variables
   #--------------------------------------------------------------------------
   @@inverted_x_cache    = {}
   @@inverted_y_cache    = {}
   @@inverted_both_cache = {}
 
   #--------------------------------------------------------------------------
   # ? Alias methods
   #--------------------------------------------------------------------------
   alias rbs_spriteset_battle_initialize initialize
   alias rbs_spriteset_battle_battleback1_bitmap battleback1_bitmap
   alias rbs_spriteset_battle_battleback2_bitmap battleback2_bitmap
 
   #--------------------------------------------------------------------------
   # ? Creates the spriteset
   #--------------------------------------------------------------------------
   def initialize
     rbs_spriteset_battle_initialize
     @battler_sprites = @enemy_sprites + @actor_sprites
     @icon_sprites = {}
   end
 
   def create_actors
     @actor_sprites = $game_party.members.collect do |actor|
       Sprite_Battler.new(@viewport1, actor)
     end
   end
 
 
   def update_actors
     @actor_sprites.each do |sprite|
       if !sprite.battler
         @actor_sprites.delete(sprite)
         sprite.dispose
       else
         sprite.update
       end
     end
     $game_party.members.each do |actor|
       if !@actor_sprites.any? { |sprite| sprite.battler == actor}
         new_sprite = Sprite_Battler.new(@viewport1, actor)
         @actor_sprites.push(new_sprite)
         new_sprite.update
         if $game_troop.turn_count > 0 || BattleManager.turn_end?
           BattleInterpreter.add_action(actor, [actor], actor.get_presentation_sequence, nil)
           SceneManager.scene.wait_for_battle_interpreter
         end
       end
     end
   end
 
   #--------------------------------------------------------------------------
   # ? checks if animating
   #--------------------------------------------------------------------------
   def animation?
     battler_sprites.any? {|sprite| sprite.animation? || sprite.moving? || BattleCamera.moving? }
   end
 
   #--------------------------------------------------------------------------
   # ? gets the battler sprites
   #--------------------------------------------------------------------------
   def battler_sprites
     @actor_sprites + @enemy_sprites
   end
 
   #--------------------------------------------------------------------------
   # ? Get the battler sprite of a target
   #--------------------------------------------------------------------------
   def battler_sprite(battler)
     @battler_sprites.each do |i|
       return i if i.battler == battler
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Creates the lower battleback
   #--------------------------------------------------------------------------
   def create_battleback1
     @back1_sprite = Plane.new(@viewport1)
     @back1_sprite.bitmap = battleback1_bitmap
     @back1_sprite.z = 0
   end
   #--------------------------------------------------------------------------
   # ? Creats the upper battleback
   #--------------------------------------------------------------------------
   def create_battleback2
     @back2_sprite = Plane.new(@viewport1)
     @back2_sprite.bitmap = battleback2_bitmap
     @back2_sprite.z = 1
   end
 
   #--------------------------------------------------------------------------
   # ? Updates lower battleback
   #--------------------------------------------------------------------------
   def update_battleback1
     z = BattleConfig::Battleback_NormalZoom
     ox = @back1_sprite.bitmap.width * 3 / 4
     oy = @back1_sprite.bitmap.height * 3 / 4
     @back1_sprite.ox = -BattleCamera.correct_x(ox)
     @back1_sprite.oy = -BattleCamera.correct_y(oy)
     zoom = BattleCamera.correct_zoom(BattleConfig::Battleback_NormalZoom)
     @back1_sprite.zoom_x = @back1_sprite.zoom_y = zoom
   end
   #--------------------------------------------------------------------------
   # ? Updates upper battleback
   #--------------------------------------------------------------------------
   def update_battleback2
     z = BattleConfig::Battleback_NormalZoom
     ox = @back2_sprite.bitmap.width * 3 / 4
     oy = @back2_sprite.bitmap.height * 3 / 4
     @back2_sprite.ox = -BattleCamera.correct_x(ox)
     @back2_sprite.oy = -BattleCamera.correct_y(oy)
     zoom = BattleCamera.correct_zoom(BattleConfig::Battleback_NormalZoom)
     @back2_sprite.zoom_x = @back2_sprite.zoom_y = zoom
   end
 
   #--------------------------------------------------------------------------
   # ? Gets the bitmap of lower battleback
   #--------------------------------------------------------------------------
   def battleback1_bitmap
     if BattleConfig::UsingDefaultBattlebacks
       return create_mirrored_battleback(rbs_spriteset_battle_battleback1_bitmap)
     else
       return rbs_spriteset_battle_battleback1_bitmap
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Gets the bitmap of upper battleback
   #--------------------------------------------------------------------------
   def battleback2_bitmap
     if BattleConfig::UsingDefaultBattlebacks
       return create_mirrored_battleback(rbs_spriteset_battle_battleback2_bitmap)
     else
       return rbs_spriteset_battle_battleback2_bitmap
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Creates the sprite of the battleback for compatibility
   #--------------------------------------------------------------------------
   def create_mirrored_battleback(battleback)
     org_w = battleback.width
     org_h = battleback.height
     bw = battleback.width << 1
     bh = battleback.height << 1
     bmp = Bitmap.new(bw, bh)
     bmp.blt(org_w >> 1, org_h >> 1, battleback, battleback.rect)
     battleback.dispose
     return bmp
   end
 
   def make_return_sequence(include_stand=true)
     battler_sprites.each do |i|
       i.make_return_sequence(include_stand)
     end
   end
 
   #--------------------------------------------------------------------------
   # ? ????????????
   #--------------------------------------------------------------------------
   def update_pictures
     $game_troop.screen.pictures.each do |pic|
       @picture_sprites[pic.number] ||= Sprite_BattlePicture.new(@viewport2, pic)
       @picture_sprites[pic.number].update
     end
   end
 
 end
 
 #===============================================================================
 # END SPRITE SECTION
 #===============================================================================
 
 #===============================================================================
 # BEGIN GAME DATA SECTION
 #===============================================================================
 
 #===============================================================================
 # * RPG::BaseItem
 #===============================================================================
 module RPG
   class BaseItem
 
     #---------------------------------------------------------------------------
     # Gets attack skill id
     #---------------------------------------------------------------------------
     def get_atk_skill_id
       return self.note[/<atk skill id:(.*?)>/mi] ? eval($1) : nil
     end
 
     #---------------------------------------------------------------------------
     # Gets guard skill id
     #---------------------------------------------------------------------------
     def get_guard_skill_id
       return self.note[/<guard skill id:(.*?)>/mi] ? eval($1) : nil
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_sequence(key)
       ex = BattleConfig::Default_SequenceNotes
       reg = /<sequence:#{key}>(.*?)<\/sequence>/mi
       ex_r = ''
       if self.is_a?(RPG::Actor) || self.is_a?(RPG::Enemy)
         ex_r = (ex[reg] ? $1 : '')
       end
       return self.note[reg] ? $1 : ex_r
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_turn_start_sequence
       get_sequence('turn start')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_turn_end_sequence
       get_sequence('turn end')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_presentation_sequence
       get_sequence('presentation')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_surprised_sequence
       get_sequence('surprised')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_preemptive_sequence
       get_sequence('preemptive')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_attack_sequence
       get_sequence('attack')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_guard_sequence
       get_sequence('guard')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_counter_sequence
       get_sequence('counter')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_die_sequence
       get_sequence('die')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_dead_sequence
       get_sequence('dead')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_revive_sequence
       get_sequence('revive')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_victory_sequence
       get_sequence('victory')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_substitute_sequence
       get_sequence('substitute')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_reflect_sequence
       get_sequence('reflect')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_item_use_sequence
       get_sequence('item')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_skill_use_sequence
       get_sequence('skill')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_stand_sequence
       get_sequence('stand')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_evade_sequence
       get_sequence('evade')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_miss_sequence
       get_sequence('miss')
     end
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_return_sequence
       get_sequence('return position')
     end
 
     #---------------------------------------------------------------------------
     # Gets the sequence used when actor is processing an input
     #---------------------------------------------------------------------------
     def get_action_selection_sequence
       get_sequence('action selection')
     end
 
     #---------------------------------------------------------------------------
     # Gets the default battler index
     #---------------------------------------------------------------------------
     def get_default_battler_index
       return self.note[/<default battler index:(.*?)>/mi] ? eval($1) : nil
     end
 
   end
 end
 
 class RPG::Skill < RPG::UsableItem
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_attack_sequence
       get_sequence('skill') == '' ? get_sequence('attack') : get_sequence('skill')
     end
 
 end
 
 class RPG::Item < RPG::UsableItem
 
     #---------------------------------------------------------------------------
     # Gets a sequence
     #---------------------------------------------------------------------------
     def get_attack_sequence
       get_sequence('item') == '' ? get_sequence('attack') : get_sequence('skill')
     end
 
 end
 
 
 #===============================================================================
 # END GAME DATA SECTION
 #===============================================================================
 
 #===============================================================================
 # BEGIN GAME OBJECTS SECTION
 #===============================================================================
 
 #===============================================================================
 # ¦ Game_Battler
 #===============================================================================
 class Game_Battler
 
   def friend_unit
     return []
   end
 
   def enemy_unit
     return []
   end
 
   def counter_skill_id
     return attack_skill_id
   end
 
   def zoom_effective?
     return true
   end
 
 end
 
 #==============================================================================
 # ¦ Game_Enemy
 #==============================================================================
 class Game_Enemy < Game_Battler
 
   #-----------------------------------------------------------------------------
   # Class atributes
   #-----------------------------------------------------------------------------
   attr_reader :atk_animation_id1
   attr_reader :atk_animation_id2
 
   #-----------------------------------------------------------------------------
   # Alias methods
   #-----------------------------------------------------------------------------
   alias rbs_game_enemy_initialize initialize
 
   #-----------------------------------------------------------------------------
   # Object Creation
   #-----------------------------------------------------------------------------
   def initialize(index, enemy_id)
     rbs_game_enemy_initialize(index, enemy_id)
     @atk_animation_id1 = enemy.note[/<atk ani1:(.*?)>/im] ? eval($1) : BattleConfig::DefaultEnemey_Ani1ID
     @atk_animation_id2 = enemy.note[/<atk ani2:(.*?)>/im] ? eval($1) : BattleConfig::DefaultEnemey_Ani2ID
     @counter_skill_id  = enemy.note[/<counter skill id:(.*?)>/im] ? eval($1) : attack_skill_id
     @weapon_1_id       = enemy.note[/<weapon 1 id:(.*?)>/im] ? eval($1) : 0
     @weapon_2_id       = enemy.note[/<weapon 2 id:(.*?)>/im] ? eval($1) : 0
   end
 
   #--------------------------------------------------------------------------
   # ? Get the attack skll id
   #--------------------------------------------------------------------------
   def attack_skill_id
     id = enemy.get_atk_skill_id
     return id ? id : super
   end
   #--------------------------------------------------------------------------
   # ? Get the guard skill id
   #--------------------------------------------------------------------------
   def guard_skill_id
     id = enemy.get_guard_skill_id
     return id ? id : super
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_turn_start_sequence
     return enemy.presentation_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_turn_end_sequence
     return enemy.presentation_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_presentation_sequence
     return enemy.get_presentation_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_surprised_sequence
     return enemy.get_surprised_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_preemptive_sequence
     return enemy.get_preemptive_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_attack_sequence
     return enemy.get_attack_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_guard_sequence
     return enemy.get_guard_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_counter_sequence
     return enemy.get_counter_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_die_sequence
     return enemy.get_die_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_dead_sequence
     return enemy.get_dead_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_revive_sequence
     return enemy.get_revive_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_victory_sequence
     return enemy.get_victory_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_substitute_sequence
     return enemy.get_substitute_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_reflect_sequence
     return enemy.get_substitute_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_item_use_sequence
     return enemy.get_item_use_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_skill_use_sequence
     return enemy.get_skill_use_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_stand_sequence
     seq = ''
     states.each do |i|
       next if !i
       seq += i.get_stand_sequence
     end
     return seq == '' ? enemy.get_stand_sequence : seq
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_evade_sequence
     return enemy.get_evade_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_miss_sequence
     return enemy.get_miss_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_return_sequence
     return enemy.get_return_sequence
   end
 
   #-----------------------------------------------------------------------------
   # Gets friend unit
   #-----------------------------------------------------------------------------
   def friend_unit
     return $game_troop
   end
 
   #-----------------------------------------------------------------------------
   # Gets enemy unit
   #-----------------------------------------------------------------------------
   def enemy_unit
     return $game_party
   end
 
   #-----------------------------------------------------------------------------
   # Gets default battler index
   #-----------------------------------------------------------------------------
   def default_battler_index
     a = enemy.get_default_battler_index
     return a ? a : BattleConfig::DefaultEnemyIndex
   end
 
   #-----------------------------------------------------------------------------
   # Gets the real presentation action according to situation
   #-----------------------------------------------------------------------------
   def get_real_presentation_action
     return get_dead_sequence if dead?
     BattleManager.surprise? ? get_preemptive_sequence : (BattleManager.preemptive? ? get_surprised_sequence : get_presentation_sequence )
   end
 
   #-----------------------------------------------------------------------------
   # Gets the counter skill id
   #-----------------------------------------------------------------------------
   def counter_skill_id
     return @counter_skill_id
   end
 
   #-----------------------------------------------------------------------------
   # has dia sequence?
   #-----------------------------------------------------------------------------
   def die_sequence?
     return enemy.note[/<die sequence on>/mi] ? true : false
   end
 
   #-----------------------------------------------------------------------------
   # Get weapons
   #-----------------------------------------------------------------------------
   def weapons
     result = []
     result.push($data_weapons[@weapon_1_id]) if @weapon_1_id > 0
     result.push($data_weapons[@weapon_2_id]) if @weapon_2_id > 0
     return result
   end
 
 end
 
 #==============================================================================
 # ¦ Game_Actor
 #==============================================================================
 class Game_Actor < Game_Battler
 
   #-----------------------------------------------------------------------------
   # Class atributes
   #-----------------------------------------------------------------------------
   attr_accessor :battler_name
   attr_accessor :battler_hue
   attr_accessor :counter_skill_id
 
   #-----------------------------------------------------------------------------
   # Alias methods
   #-----------------------------------------------------------------------------
   alias rbs_game_actor_setup setup
   alias rbs_game_actor_make_actions make_actions
 
   #--------------------------------------------------------------------------
   # ? Setups an actor by ID
   #--------------------------------------------------------------------------
   def setup(actor_id)
     rbs_game_actor_setup(actor_id)
     @battler_name = actor.note[/<battler name:(.*?)>/im] ? $1 : @character_name
     @battler_hue  = actor.note[/<battler hue:(.*?)>/im] ? $1.to_i : 0
     @custom_screen_x = actor.note[/<screen x:(.*?)>/im] ? $1.to_i : nil
     @custom_screen_y = actor.note[/<screen y:(.*?)>/im] ? $1.to_i : nil
     id1 = actor.note[/<atk ani1:(.*?)>/im] ? Kernel.eval($1) : ($data_classes[@class_id].note[/<atk ani1:(.*?)>/im] ? Kernel.eval($1) : BattleConfig::DefaultEnemey_Ani1ID)
     id2 = actor.note[/<atk ani2:(.*?)>/im] ? Kernel.eval($1) : ($data_classes[@class_id].note[/<atk ani2:(.*?)>/im] ? Kernel.eval($1) : BattleConfig::DefaultEnemey_Ani2ID)
     @default_atk_animation_id1 = id1
     @default_atk_animation_id2 = id2
     c_s_id = $data_classes[@class_id].note[/<counter skill id:(.*?)>/im] ? Kernel.eval($1) : attack_skill_id
     @counter_skill_id  = actor.note[/<counter skill id:(.*?)>/im]  ? Kernel.eval($1) : c_s_id
   end
 
   #--------------------------------------------------------------------------
   # ? Use sprite?
   #--------------------------------------------------------------------------
   def use_sprite?
     return true
   end
 
   #--------------------------------------------------------------------------
   # ? Get battle screen x position
   #--------------------------------------------------------------------------
   def screen_x
     return 0 if !self.index
     return @custom_screen_x ? @custom_screen_x : BattleConfig::ActorPos[self.index][0]
   end
 
   #--------------------------------------------------------------------------
   # ? Get battle screen y position
   #--------------------------------------------------------------------------
   def screen_y
     return 0 if !self.index
     return @custom_screen_y ? @custom_screen_y : BattleConfig::ActorPos[self.index][1]
   end
 
   #--------------------------------------------------------------------------
   # ? Get battle screen z position
   #--------------------------------------------------------------------------
   def screen_z
     return 100
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_turn_start_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_turn_start_sequence
     end
     return seq != '' ? seq : actor.get_turn_start_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_turn_end_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_turn_end_sequence
     end
     return seq != '' ? seq : actor.get_turn_end_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_presentation_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_presentation_sequence
     end
     return seq != '' ? seq : actor.get_presentation_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_surprised_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_surprised_sequence
     end
     return seq != '' ? seq : actor.get_surprised_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_preemptive_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_preemptive_sequence
     end
     return seq != '' ? seq : actor.get_preemptive_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_attack_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_attack_sequence
     end
     return seq != '' ? seq : actor.get_attack_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_guard_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_guard_sequence
     end
     return seq != '' ? seq : actor.get_guard_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_counter_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_counter_sequence
     end
     return seq != '' ? seq : actor.get_counter_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_die_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_die_sequence
     end
     return seq != '' ? seq : actor.get_die_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_dead_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_dead_sequence
     end
     return seq != '' ? seq : actor.get_dead_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_revive_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_revive_sequence
     end
     return seq != '' ? seq : actor.get_revive_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_victory_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_victory_sequence
     end
     return seq != '' ? seq : actor.get_victory_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_substitute_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_substitute_sequence
     end
     return seq != '' ? seq : actor.get_substitute_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_reflect_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_reflect_sequence
     end
     return seq != '' ? seq : actor.get_reflect_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_item_use_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_item_use_sequence
     end
     return seq != '' ? seq : actor.get_item_use_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_skill_use_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_skill_use_sequence
     end
     return seq != '' ? seq : actor.get_skill_use_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_stand_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_stand_sequence if seq == ''
     end
     states.each do |i|
       next if !i
       seq += i.get_stand_sequence if seq == ''
     end
     return seq != '' ? seq : actor.get_stand_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_evade_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_evade_sequence
     end
     return seq != '' ? seq : actor.get_evade_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_miss_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_miss_sequence if seq == ''
     end
     return seq != '' ? seq : actor.get_miss_sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Get sequence
   #--------------------------------------------------------------------------
   def get_return_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_return_sequence if seq == ''
     end
     states.each do |i|
       next if !i
       seq += i.get_return_sequence if seq == ''
     end
     return seq != '' ? seq : actor.get_return_sequence
   end
 
   #---------------------------------------------------------------------------
   # Gets the sequence used when actor is processing an input
   #---------------------------------------------------------------------------
   def get_action_selection_sequence
     seq = ''
     equips.each do |i|
       next if !i
       seq += i.get_action_selection_sequence  if seq == ''
     end
     states.each do |i|
       next if !i
       seq += i.get_action_selection_sequence  if seq == ''
     end
     return seq != '' ? seq : actor.get_action_selection_sequence
   end
 
   #-----------------------------------------------------------------------------
   # Gets the real presentation action according to situation
   #-----------------------------------------------------------------------------
   def get_real_presentation_action
     return get_dead_sequence if dead?
     BattleManager.surprise? ? get_surprised_sequence : (BattleManager.preemptive? ? get_preemptive_sequence : get_presentation_sequence )
   end
 
   #-----------------------------------------------------------------------------
   # Performs collapse effect
   #-----------------------------------------------------------------------------
   def perform_collapse_effect
     case collapse_type
     when 0
       @sprite_effect_type = :collapse
       Sound.play_enemy_collapse
     when 1
       @sprite_effect_type = :boss_collapse
       Sound.play_boss_collapse1
     when 2
       @sprite_effect_type = :instant_collapse
     end
   end
 
   #-----------------------------------------------------------------------------
   # Has die sequence
   #-----------------------------------------------------------------------------
   def die_sequence?
     return actor.note[/<die sequence on>/mi] ? true : false
   end
 
   #--------------------------------------------------------------------------
   # ? Get the attack skill id
   #--------------------------------------------------------------------------
   def attack_skill_id
     id = actor.get_atk_skill_id
     wpns = weapons.compact
     if wpns.size > 0
       w = wpns[rand(wpns.size)]
       id2 = w.get_atk_skill_id
       id  = id2 if id2
     end
     return id ? id : super
   end
   #--------------------------------------------------------------------------
   # ? Get the guard skill id
   #--------------------------------------------------------------------------
   def guard_skill_id
     id = actor.get_guard_skill_id
     armrs = armors.compact
     if armrs.size > 0
       a = armrs[rand(armrs.size)]
       id2 = a.get_guard_skill_id
       id  = id2 if id2
     end
     return id ? id : super
   end
 
   #-----------------------------------------------------------------------------
   # Get friend unit
   #-----------------------------------------------------------------------------
   def friend_unit
     return $game_party
   end
 
   #-----------------------------------------------------------------------------
   # Get enemy unit
   #-----------------------------------------------------------------------------
   def enemy_unit
     return $game_troop
   end
 
   #-----------------------------------------------------------------------------
   # Get default battler index
   #-----------------------------------------------------------------------------
   def default_battler_index
     a = actor.get_default_battler_index
     return a ? a : BattleConfig::DefaultActorIndex
   end
 
   #-----------------------------------------------------------------------------
   # Get attack animation 1
   #-----------------------------------------------------------------------------
   def atk_animation_id1
     if dual_wield?
       return weapons[0].animation_id if weapons[0]
       return weapons[1] ? 0 : @default_atk_animation_id1
     else
       return weapons[0] ? weapons[0].animation_id : 1
     end
   end
 
   #-----------------------------------------------------------------------------
   # Get attack animation 2
   #-----------------------------------------------------------------------------
   def atk_animation_id2
     if dual_wield?
       return weapons[1] ? weapons[1].animation_id : @default_atk_animation_id2
     else
       return 0
     end
   end
 
   #-----------------------------------------------------------------------------
   # Get counter attack skill id
   #-----------------------------------------------------------------------------
   def counter_skill_id
     id = @counter_skill_id
     equips.each do |i|
       next if !i
       id = i.note[/<counter skill id:(.*?)>/im] ? Kernel.eval($1) : id
     end
     return id
   end
 
 end
 
 #==============================================================================
 # ¦ Game_Picture
 #------------------------------------------------------------------------------
 #  ??????????????????? Game_Pictures ??????????
 # ??????????????????????????
 #==============================================================================
 
 class Game_Picture
 
   #-----------------------------------------------------------------------------
   # Class atributes
   #-----------------------------------------------------------------------------
   attr_accessor :animation_id
   attr_accessor :animation_flip
 
   #-----------------------------------------------------------------------------
   # Alias methods
   #-----------------------------------------------------------------------------
   alias rbs_game_picture_init_basic init_basic
 
   #-----------------------------------------------------------------------------
   # Start basic information
   #-----------------------------------------------------------------------------
   def init_basic
     @animation_id = 0
     @animation_flip = false
     rbs_game_picture_init_basic
   end
 
   #-----------------------------------------------------------------------------
   #  Move ex
   #-----------------------------------------------------------------------------
   def move_ex(x, y, duration)
     @target_x = x.to_f
     @target_y = y.to_f
     @duration = duration
   end
 
   #-----------------------------------------------------------------------------
   # Set zoom
   #-----------------------------------------------------------------------------
   def set_zoom(zoom_x, zoom_y, duration)
     @target_zoom_x = zoom_x.to_f
     @target_zoom_y = zoom_y.to_f
     @duration = duration
   end
 
   #-----------------------------------------------------------------------------
   # Set opacity
   #-----------------------------------------------------------------------------
   def set_opacity(opacity, duration)
     @target_opacity = opacity.to_f
     @duration = duration
   end
 
   #-----------------------------------------------------------------------------
   # Set animation
   #-----------------------------------------------------------------------------
   def set_animation(animation_id, flip=false)
     @animation_id = animation_id
     @animation_flip = flip
   end
 
 end
 
 #===============================================================================
 # END GAME OBJECTS SECTION
 #===============================================================================
 
 #===============================================================================
 # BEGIN WINDOW SECTION
 #===============================================================================
 
 if !$imported["YEA-BattleEngine"] # If you use YEA please configure it from YEA.
 
 
 
 end # if $imported["YEA-BattleEngine"]
 
 #==============================================================================
 # ¦ Window_BattleItem
 #==============================================================================
 class Window_BattleItem < Window_ItemList
 
   #--------------------------------------------------------------------------
   # ? Object creation
   #--------------------------------------------------------------------------
   def initialize(help_window, info_viewport)
     y = Graphics.height - window_height
     super(0, y, window_width, window_height)
     self.visible = false
     @help_window = help_window
     @info_viewport = info_viewport
   end
 
   #--------------------------------------------------------------------------
   # ? Get window width
   #--------------------------------------------------------------------------
   def window_width
     Graphics.width
   end
 
   #--------------------------------------------------------------------------
   # ? Get window height
   #--------------------------------------------------------------------------
   def window_height
     fitting_height(visible_line_number)
   end
 
   #--------------------------------------------------------------------------
   # ? Get visible line muber
   #--------------------------------------------------------------------------
   def visible_line_number
     return 4
   end
 
 
 end
 
 #==============================================================================
 # ¦ Window_BattleSkill
 #------------------------------------------------------------------------------
 #  ???????????????????????????
 #==============================================================================
 
 class Window_BattleSkill < Window_SkillList
 
   #--------------------------------------------------------------------------
   # ? Object Creation
   #--------------------------------------------------------------------------
   def initialize(help_window, info_viewport)
     y = Graphics.height - window_height
     super(0, y, window_width, window_height)
     self.visible = false
     @help_window = help_window
     @info_viewport = info_viewport
   end
   #--------------------------------------------------------------------------
   # ? Gets window width
   #--------------------------------------------------------------------------
   def window_width
     Graphics.width
   end
   #--------------------------------------------------------------------------
   # ? Gets window height
   #--------------------------------------------------------------------------
   def window_height
     fitting_height(visible_line_number)
   end
 
   #--------------------------------------------------------------------------
   # ? Get visible line muber
   #--------------------------------------------------------------------------
   def visible_line_number
     return 4
   end
 
 end
 
 #===============================================================================
 # END WINDOW SECTION
 #===============================================================================
 
 #===============================================================================
 # BEGIN SCENE SECTION
 #===============================================================================
 
 #==============================================================================
 # ¦ Scene_Battle
 #==============================================================================
 class Scene_Battle < Scene_Base
   #--------------------------------------------------------------------------
   # ? Alias methods
   #--------------------------------------------------------------------------
   alias rbs_scene_battle_start start
   alias rbs_scene_battle_post_start post_start
   alias rbs_scene_battle_battle_start battle_start
   alias rbs_scene_battle_use_item use_item
   alias rbs_scene_battle_update_basic update_basic
   alias rbs_scene_battle_start_actor_command_selection start_actor_command_selection
   alias rbs_scene_battle_next_command next_command
   alias rbs_scene_battle_prior_command prior_command
 
   #--------------------------------------------------------------------------
   # ? Start scene
   #--------------------------------------------------------------------------
   def start
     BattleCamera.start
     rbs_scene_battle_start
     BattleInterpreter.start(@spriteset)
     setup_battle_commands
   end
 
   #--------------------------------------------------------------------------
   # ? Post star scene
   #--------------------------------------------------------------------------
   def post_start
     rbs_scene_battle_post_start
     show_presentation_animation
   end
 
   #--------------------------------------------------------------------------
   # ? Start battle
   #--------------------------------------------------------------------------
   def battle_start
     rbs_scene_battle_battle_start
   end
 
   #--------------------------------------------------------------------------
   # ? Get next command
   #--------------------------------------------------------------------------
   def next_command
     if BattleManager.actor
       actor = BattleManager.actor
       BattleInterpreter.add_looping_action(actor, actor.get_stand_sequence)
       BattleInterpreter.add_action(actor, [actor], actor.get_turn_end_sequence, $data_skills[1])
       wait_for_battle_interpreter
     end
     rbs_scene_battle_next_command
   end
 
   #--------------------------------------------------------------------------
   # ? Get Prior command
   #--------------------------------------------------------------------------
   def prior_command
     if BattleManager.actor
       actor = BattleManager.actor
       BattleInterpreter.add_looping_action(actor, actor.get_stand_sequence)
       BattleInterpreter.add_action(actor, [actor], actor.get_turn_end_sequence, $data_skills[1])
       wait_for_battle_interpreter
     end
     rbs_scene_battle_prior_command
   end
 
   #--------------------------------------------------------------------------
   # ? Show presentation animation
   #--------------------------------------------------------------------------
   def show_presentation_animation
     @spriteset.update
     act = @party_command_window.active
     @party_command_window.deactivate
     @party_command_window.hide
     for member in $game_party.members+$game_troop.members
       sequence = member.get_real_presentation_action
       BattleInterpreter.add_action(member, [member], sequence, $data_skills[1])
     end
     wait_for_battle_interpreter
     wait(20)
     @spriteset.make_return_sequence
     wait_for_battle_interpreter
     if $imported["YEA-BattleEngine"]
       @party_command_window.show
       @party_command_window.active = act
     else
       @party_command_window.activate
       @party_command_window.show
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Start actor command selection
   #--------------------------------------------------------------------------
   def start_actor_command_selection
     if BattleManager.actor
       actor = BattleManager.actor
       BattleInterpreter.add_looping_action(actor, actor.get_action_selection_sequence)
       BattleInterpreter.add_action(actor, [actor], actor.get_turn_start_sequence, $data_skills[1])
       wait_for_battle_interpreter
     end
     rbs_scene_battle_start_actor_command_selection
   end
 
   #--------------------------------------------------------------------------
   # ? Show attack animation
   #--------------------------------------------------------------------------
   def show_attack_animation(targets)
     show_normal_animation(targets, @subject.atk_animation_id1, false)
     wait_for_animation
     show_normal_animation(targets, @subject.atk_animation_id2, true)
   end
 
   #--------------------------------------------------------------------------
   # ? Use item
   #--------------------------------------------------------------------------
   def use_item
     setup_dead_battlers
     item = @subject.current_action.item
     sequence = get_sequence(@subject, item)
     @log_window.display_use_item(@subject, item)
     @subject.use_item(item)
     if $imported["YEA-LunaticObjects"]
       lunatic_object_effect(:before, item, @subject, @subject)
     end
     if sequence == ''
       refresh_status
       targets = @subject.current_action.make_targets.compact
       show_animation(targets, item.animation_id)
       targets.each {|target| item.repeats.times { invoke_item(target, item) } }
     else
       targets = @subject.current_action.make_targets.compact
       if $imported["YEA-TargetManager"]
         if item.for_random?
           targets = targets.collect do |target|
             alive_random_target(target, item)
           end
         end
       end
       process_casting_animation if $imported["YEA-CastAnimations"]
       BattleInterpreter.add_action(@subject, targets, sequence, item)
       wait_for_battle_interpreter
     end
     if $imported["YEA-LunaticObjects"]
       lunatic_object_effect(:after, item, @subject, @subject)
     end
     finish_item_use
   end
 
   def setup_dead_battlers
     @dead_battlers = []
     for battler in $game_troop.dead_members+$game_party.dead_members
       @dead_battlers.push(battler) if battler.dead?
     end
   end
 
   def finish_item_use
     @spriteset.make_return_sequence
     wait_for_battle_interpreter
     for battler in $game_troop.members+$game_party.members
       if battler.dead? && !@dead_battlers.include?(battler)
         @dead_battlers.delete(battler)
         if battler.die_sequence?
           sequence = battler.get_die_sequence
           BattleInterpreter.add_action(battler, [battler], sequence, nil, false)
         else
           battler.perform_collapse_effect
         end
       elsif battler.alive? &&  @dead_battlers.include?(battler)
         sequence = battler.get_revive_sequence
         BattleInterpreter.add_action(battler, [battler], sequence, nil, false)
       end
     end
     wait_for_battle_interpreter
   end
 
   #--------------------------------------------------------------------------
   # ? Gets the sequence for an item
   #--------------------------------------------------------------------------
   def get_sequence(subject, item)
     sequence = item.get_attack_sequence
     if item.is_a?(RPG::Skill) and item.id == subject.attack_skill_id
       seq = subject.get_attack_sequence
       if seq != ''
         sequence = seq
       end
     elsif item.is_a?(RPG::Skill) and item.id == subject.guard_skill_id
       seq = subject.get_guard_sequence
       if seq != ''
         sequence = seq
       end
     end
     if sequence == ''
       if item.is_a?(RPG::Skill)
         seq = subject.get_skill_use_sequence
         if seq != ''
           sequence = seq
         end
       elsif item.is_a?(RPG::Item)
         seq = subject.get_item_use_sequence
         if seq != ''
           sequence = seq
         end
       end
     end
     return sequence
   end
 
   #--------------------------------------------------------------------------
   # ? Wait for battle interpreter
   #--------------------------------------------------------------------------
   def wait_for_battle_interpreter
     update_for_wait while BattleInterpreter.running?
     wait_for_animation
   end
 
   #--------------------------------------------------------------------------
   # ? Basic update
   #--------------------------------------------------------------------------
   def update_basic
     rbs_scene_battle_update_basic
     BattleCamera.update
     BattleInterpreter.update
   end
 
   #--------------------------------------------------------------------------
   # ? Show animation ex
   #--------------------------------------------------------------------------
   def show_animation_ex(targets, animation_id, mirror = false)
     return if !targets || targets.empty?
     animation = $data_animations[animation_id]
     if animation
       if animation.to_screen?
         target = targets[0]
         target.start_animation(animation, mirror)
       else
         targets.each do |target|
           target.start_animation(animation, mirror)
         end
       end
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Apply item efects
   #--------------------------------------------------------------------------
   def apply_item_effects_ex(user, target, item)
     if $imported["YEA-LunaticObjects"]
       lunatic_object_effect(:prepare, item, user, target)
     end
     target.item_apply(user, item)
     if $imported["YEA-LunaticObjects"]
       lunatic_object_effect(:during, item, user, target)
     end
     refresh_status
     @log_window.display_action_results(target, item)
   end
 
   #--------------------------------------------------------------------------
   # ? Invoke counter attack
   #--------------------------------------------------------------------------
   def invoke_counter_attack_ex(user, target, item)
     @log_window.display_counter(target, item)
     attack_skill = $data_skills[target.counter_skill_id]
     sequence = attack_skill.get_counter_sequence
     sequence = target.get_counter_sequence if sequence == ''
     BattleInterpreter.add_action(target, [user], sequence, attack_skill, false)
     @log_window.display_action_results(target, attack_skill)
   end
 
   #--------------------------------------------------------------------------
   # ? Invoke magic reflection
   #--------------------------------------------------------------------------
   def invoke_magic_reflection_ex(action, target)
     item = action.item
     user = action.user
     @log_window.display_reflection(target, item)
     action.targets.delete(target)
     action.targets.push(user)
     sequence = target.get_reflect_sequence
     BattleInterpreter.add_action(target, [user], sequence, item, false)
   end
 
   #--------------------------------------------------------------------------
   # ? Apply substitute
   #--------------------------------------------------------------------------
   def apply_substitute_ex(action, target, item)
     if check_substitute(target, item)
       substitute = target.friends_unit.substitute_battler
       if substitute && target != substitute && !@substitutes.include?(substitute)
         @log_window.display_substitute(substitute, target)
         sequence = substitute.get_substitute_sequence
         action.targets.delete(target)
         action.targets.push(substitute)
         @substitutes.push(substitute)
         BattleInterpreter.add_action(substitute, [target], sequence, item)
       end
     end
   end
 
   #--------------------------------------------------------------------------
   # ? Get battler sprites
   #--------------------------------------------------------------------------
   def get_sprites(battlers)
     battlers.collect do |battler|
       @spriteset.battler_sprite(battler)
     end
   end
 
 end
 
 #===============================================================================
 # END SCENE SECTION
 #===============================================================================
 
 #===============================================================================
 # START YEA COMPATIBILITY
 #===============================================================================
 
 if $imported["YEA-BattleEngine"]
 
 #==============================================================================
 # ¦ Sprite_Popup
 #==============================================================================
 
 class Scene_Battle < Scene_Base
   attr_accessor :spriteset
 end
 
 class Sprite_Popup < Sprite_Base
 
   attr_accessor :current_x
   attr_accessor :current_y
 
   alias rbs_yea_sprite_popup_create_popup_bitmap create_popup_bitmap
 
   #--------------------------------------------------------------------------
   # create_popup_bitmap
   #--------------------------------------------------------------------------
   def create_popup_bitmap
     rbs_yea_sprite_popup_create_popup_bitmap
     @current_x = @battler.sprite.current_x
     @current_y = @battler.sprite.current_y
     @current_x += rand(4) - rand(4) if @battler.sprite.popups.size >= 1
     @current_x -= SceneManager.scene.spriteset.viewport1.ox
     @current_y  = @battler.sprite.current_y - @battler.sprite.oy/2
     @current_y -= @battler.sprite.oy/2 if @battler.actor?
     @current_y -= SceneManager.scene.spriteset.viewport1.oy
     update
   end
 
   #--------------------------------------------------------------------------
   # update
   #--------------------------------------------------------------------------
   def update
     super
     @current_zoom_x = 0 if !@current_zoom_x
     @current_zoom_y = 0 if !@current_zoom_y
     @current_x = self.x if !@current_x
     @current_y = self.y if !@current_y
     #---
     if @flags.include?("critical") && YEA::BATTLE::FLASH_CRITICAL
       @hue_duration = 2 if @hue_duration == nil || @hue_duration == 0
       @hue_duration -= 1
       self.bitmap.hue_change(15) if @hue_duration <= 0
     end
     #---
     if @zoom_direction == "up"
       @current_zoom_x = [@current_zoom_x + 0.075, @target_zoom].min
       @current_zoom_y = [@current_zoom_y + 0.075, @target_zoom].min
     else
       @current_zoom_x = [@current_zoom_x - 0.075, @target_zoom].max
       @current_zoom_y = [@current_zoom_y - 0.075, @target_zoom].max
     end
     self.zoom_x = BattleCamera.correct_zoom(@current_zoom_x)
     self.zoom_y = BattleCamera.correct_zoom(@current_zoom_y)
 
     self.x = BattleCamera.correct_x(@current_x)
     self.y = BattleCamera.correct_y(@current_y)
 
     #---
     @full -= 1
     return if @full > 0
     @current_y -= 1
     self.opacity -= @fade
     self.y = BattleCamera.correct_y(@current_y)
   end
 
 end
 
 class Sprite_Battler < Sprite_Base
 
   alias rbs_yea_create_new_popup create_new_popup
 
   #--------------------------------------------------------------------------
   # new method: create_new_popup
   #--------------------------------------------------------------------------
   def create_new_popup(value, rules, flags)
     return if @battler == nil
     return if flags & @popup_flags != []
     for popup in @popups
       popup.current_y -= 24
     end
     rbs_yea_create_new_popup(value, rules, flags)
   end
 
 end
 
 end
 
 #===============================================================================
 # END YEA COMPATIBILITY
 #===============================================================================
 
 #===============================================================================
 # END OF FILE!!!
 #===============================================================================