[ASK]Escape Meter pada Atoa ATB

escape_rate = Escape_Time * enemies_agi / (actors_agi * Speed)

#==============================================================================
# Atoa's Active Time Battle Version
# By Atoa
#==============================================================================
# This Script adds a time bar system to the game
# The configurations are explained below
#==============================================================================

module Atoa 
  # Do not remove or change these lines
  Cast_Time = {}
  Cast_Cancel = {}
  ATB_Freeze = {}
  ATB_Delay = {}
  # Do not remove or change these lines

  # Waiting Mode
  Wait_Mode = 0
  # 0 = On Hold Battle: the bar stops to select actions, skills and itens
  # 1 = Semi On Hold Battle: the bar stop to select itens and skills.
  # 2 = 100% Active Battle: the bar will never stop.
 
  # Pause the bar when a battler is executing an action?
  Wait_Act_End = true
 
  # Stop time bar during damage animation?
  Pause_if_Damaged = true
 
  # Show individual time bars for the battlers?
  Meters = true
  # Hide individual meters toghter with the status screen?
  Hide_Meters = false

  # Show a single bar that indicates the battler's action order?
  Bars = false
  # Hide singe bar toghter with the status screen?
  Hide_Bars = false
   
  # Battle Speed
  Atb_Speed = 50.0
 
  # Initial bar value modifier
  Atb_Initial_Value = 0
 
  # Multiplication rate of the initial bar value
  Atb_Initial_Rate  = 1.0
 
  # ATB's maximum value, only change if you know what you doing.
  Max_Atb = 1000
 
  # Agility Modifier, The higher this value, the lower is the diference between
  # battlers with different agility
  Atb_Agi_Modifier = 5
   
  # Makes the bar gorws faster if no actor is active
  Faster_if_inactive = false
 
  # Definition of turn shifting.
  # This definition must be used for the duration of effects and
  # battle event conditions
  # This value does not count to enemies actions conditions
  Custom_Turn_Count = 0
  # 0 = By number of fighters
  # 1 = By number of executed actions
  # 2 = By time (in frames)
 
  # If 'Custom_Turn_Count = 1', define how many actions are equal to 1 turn
  Action_Turn_Count = 10
 
  # If 'Custom_Turn_Count = 2', define how much time (in frames) are equal to 1 turn
  Time_Turn_Count = 600 # 20 frames is about 1 second
 
  # Activate a timer for the casting of magical skills?
  Magic_Skill_Cast = true
 
  # Activate a timer for the casting of physical skills?
  Physical_Skill_Cast = false
 
  # Activate a timer for the casting of itens?
  Item_Cast = false
 
  # Set the escape style
  Escape_Type = 2
  # 0 = Escape options is shown on the character's action menu
  # 1 = Keep pressed the key set in Escape_Input to escape
  #    shows a message on the screen
  # 2 = Keep pressed the key set in Escape_Input to escape
  #    shows an escape bar
 
  # Key that must be pressed to escape
  Escape_Input = Input::Y
   
  # Key that must be pressed to change the input battler
  Next_Input = Input::B
 
  # Key that must be pressed to end battler turn
  Cancel_Input = Input::A
 
  # Remember to not leave any equal input
  # Input::A  = Keyborard:Z
  # Input::B  = Keyborard:X
  # Input::C  = Keyborard:C
  # Input::X  = Keyborard:A
  # Input::Y  = Keyborard:S
  # Input::Z  = Keyborard:D
  # Input::L  = Keyborard:Q
  # Input::R  = Keyborard:W
 
  # Show the name for the escape option when Escape_Type = 0
  Escape_Name = 'Escape'
 
  # Escape message when Escape_Type = 1
  Escape_Message = 'Escaping...'
  Cant_Escape_Message = "Can't Escape!"
 
  # Time (in frames) needed to escape when Escape_Type > 0
  # it is affected by the agility of characters and enemies
  Escape_Time = 6000
 
  # Name of the graphic file when Escape_Type = 2
  Escape_Skin = 'ESCAPEMeter'
 
  # Position of the Fleeing Bar
  Escape_Meter_Pos_Type = 0
  # 0 = Above the characters
  # 1 = Upper-Mid of the screen
  # 2 = Custom position
 
  # Custom position of the Fleeing Bar when Escape_Meter_Pos_Type = 2
  Escape_Meter_Position = [240,64]
 
  # Time Bar configurations
  Meter_Skin  = 'ATBMeter' # Graphic file name that represents the bars
                          # must be on the Graphic/Windowskins folder
 
  # Position of the character's Time Bars
  Meter_Pos_Style = 5
  # 0 = Horizontal Pattern, not centralized
  # 1 = Horizontal Pattern, centralized
  # 2 = Vertical Bars
  # 3 = Under the characters
  # 5 = Custom
 
  # Readjust the Time Bar's position on the battle screen
  X_Meter = 10  # X position of the Bars
  Y_Meter = 440 # Y position of the Bars

  # Custom Time Bar position, only valid when Meter_Pos_Style = 5
  Meter_Position = [[380,440],[208,440],[32,440],[30,440]]

  # Coordinate 'Z' (height) of the Meter image if Meter_Pos_Style = 5
  Meter_Height = 420
 
  # Position of the enemie's Time Bars
  Enemy_Meter = 0
  # 0 = No time bars for the enemies
  # 1 = Under the enemy
  # 2 = Vertical list on the Side
 
  # Configuration of the Action Bars.
  Bar_Skin = 'ATBBar' # Name of the graphic file that represents the bar, must be
                      # on the Graphics/Windowskins folder
  X_Bar    = 128      # X position of the Bars
  Y_Bar    =  80      # Y position of the Bars
 
  # Name of the default graphic Icon for characters
  Default_Party_Icon = '050-Skill07'
  # Individual character's Icons
  # Must be configured on the following way: 'Battler file name' => 'Icon file name'
  Party_Icon = {
    '%Noa' => 'Atoa-Icon',
    '%Alpin' => 'Atoa-Icon',
    'Nanaly' => 'DarkLuar-Icon',
    'Klarth' => 'Tunicoelp-Icon',
    'Max' => 'Maranguape-Icon',
  }
 
  # Name of the default graphic Icon for enemies
  Default_Enemy_Icon = 'Shade'
  # Individual icons for enemies
  # must be configured on the following way: 'Battler file name' => 'Icon file name'
  Enemy_Icon = {}
 
  # Sound effect played when teh character's turn comes. nil for no sound
  Command_Up_SE = 'Incomingtransmission'
     
  #¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
  # CAST SETTINGS
  #¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
  # Chanting default pose, if nil, no pose is used.
  Chanting_Pose = nil

  # To add an pose to an skill or item, add this effect to the setting of the
  # skill or the item.
  # 'Chanting/**'
  #  ** must be the Pose ID.
 
  # To set an chanting pose for an specific graphic, add this to the graphic setting:
  # 'Chanting' => Pose ID.
 
  # Set here the cast time for each item and skill
  # By default all items have the cast speed = 0 (that means, no cast).
  # 
  #  Cast_Time[Action_Type] = {Action_ID => [Speed, status]}
  #    Action_Type = 'Skill' for skills, 'Item' for items
  #    Action_ID = ID of the skill or item
  #    Speed = cast speed, higher value = faster cast
  #      recomended values between 500-100
  #    Status = The status that the cast speed is based
  #      if nil, the cast will have fixed speed
  #      the status can be:
  #        'hp', 'sp', 'level', 'str', 'dex', 'int', 'agi'

  Cast_Time['Skill'] = {1 => [500,'int'], 2 => [400,'int'], 3 => [300,'int'],
    7 => [500,'int'], 8 => [400,'int'], 9 => [300,'int'], 10 => [500,'int'],
    11 => [400,'int'], 12 => [300,'int'], 13 => [500,'int'], 14 => [400,'int'],
    15 => [300,'int'], 16 => [500,'int'], 17 => [400,'int'], 18 => [300,'int'],
    19 => [500,'int'], 20 => [400,'int'], 21 => [300,'int'], 22 => [500,'int'],
    23 => [400,'int'], 24 => [300,'int'], 25 => [500,'int'], 26 => [400,'int'],
    27 => [300,'int'], 28 => [500,'int'], 29 => [400,'int'], 30 => [300,'int']}
 
  Cast_Time['Item'] = {1 => [500,'int'], 2 => [500,'int'], 3 => [500,'int'],
    7 => [500,'int'], 8 => [500,'int'], 9 => [500,'int'], 10 => [500,'int'],
    11 => [500,'int'], 12 => [500,'int']}
 
  #¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
  # SETTINGS OF ACTIONS THAT CHANGE THE ATB
  #¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
  # Actions that may cause changes on the target ATB
 
  # Chance that all actions have to cancel skill cast of the target.
  # This value is used for all actions that don't have individual definition.
  Base_Cast_Cancel = 0
   
  # Set here the chance that each action have of canceling the cast of target
  # 
  #  Cast_Cancel[Action_Type] = {Action_ID => Rate}
  #    Action_Type = 'Skill' for skills, 'Item' for items, 'Weapon' for weapons
  #    Action_ID = ID of the skill, item or weapon
  #    Rate = chance of calceling cast, increases with damage caused.
  #
  # Important: if tha action is an physical skill, the weapon cancel chance is
  #  also applied (the values aren't added, each one are calculated separatedely)
 
  #--------------------------------------------------------------------------
  # Pause on the ATB bar when recive damage
  # This value is used for all actions that don't have individual definition.
  # Time in frames that the ATB bar will be stoped, increases with damage caused.
  Base_ATB_Freeze = 0
   
  # Set here the actions that will cause ATB pause
  # 
  #  Cast_Cancel[Action_Type] = {Action_ID => Pause}
  #    Action_Type = 'Skill' for skills, 'Item' for items, 'Weapon' for weapons
  #    Action_ID = ID of the skill, item or weapon
  #    Pause = ATB pause time, increases with damage caused.
  #
  # Important: if tha action is an physical skill, the weapon pause is also calculated
 
  #--------------------------------------------------------------------------
  # Delay on the ATB bar when recive damage
  # This value is used for all actions that don't have individual definition.
  Base_ATB_Delay = 0
   
  # Set here the actions that will cause ATB delay
  # 
  #  Cast_Cancel[Action_Type] = {Action_ID => Delay}
  #    Action_Type = 'Skill' for skills, 'Item' for items, 'Weapon' for weapons
  #    Action_ID = ID of the skill, item or weapon
  #    Delay = ATB delay value, increases with damage caused.
  #
  # Important: if tha action is an physical skill, the weapon delay is also calculated

end

#==============================================================================
# ¦ Atoa Module
#==============================================================================
$atoa_script = {} if $atoa_script.nil?
$atoa_script['Atoa ATB'] = true

#==============================================================================
# ¦ RPG::Skill
#==============================================================================
class RPG::Skill
  #----------------------------------------------------------------------------
  include Atoa
  #----------------------------------------------------------------------------
  def cast_speed(battler)
    if Cast_Time != nil and Cast_Time['Skill'] != nil and Cast_Time['Skill'][@id] != nil
      cast1 = Cast_Time['Skill'][@id][0]
      if Cast_Time['Skill'][@id][1].nil?
        cast2 = 200
      else
        if Cast_Time['Skill'][@id][1] == 'level'
          cast2 = (eval("battler.#{Cast_Time['Skill'][@id][1]}") * 2) + 100
        elsif Cast_Time['Skill'][@id][1] == 'hp' or Cast_Time['Skill'][@id][1] == 'sp'
          cast2 = (eval("battler.#{Cast_Time['Skill'][@id][1]}") / 50) + 100
        else
          cast2 = (eval("battler.#{Cast_Time['Skill'][@id][1]}") / 5) + 100
        end
      end
      return (cast1 * cast2).to_i
    end
    return 0
  end
end

#==============================================================================
# ¦ RPG::Item
#==============================================================================
class RPG::Item
  #----------------------------------------------------------------------------
  include Atoa
  #----------------------------------------------------------------------------
  def cast_speed(battler)
    if Cast_Time != nil and Cast_Time['Item'] != nil and Cast_Time['Item'][@id] != nil
      cast1 = Cast_Time['Item'][@id][0]
      if Cast_Time['Item'][@id][1].nil?
        cast2 = 200
      else
        if Cast_Time['Item'][@id][1] == 'level'
          cast2 = (eval("battler.#{Cast_Time['Item'][@id][1]}") * 2) + 100
        elsif Cast_Time['Item'][@id][1] == 'hp' or Cast_Time['Item'][@id][1] == 'sp'
          cast2 = (eval("battler.#{Cast_Time['Item'][@id][1]}") / 50) + 100
        else
          cast2 = (eval("battler.#{Cast_Time['Item'][@id][1]}") / 5) + 100
        end
      end
      return cast1 * cast2
    end
    return 0
  end
end

#==============================================================================
# ¦ Game_Temp
#==============================================================================
class Game_Temp
  #--------------------------------------------------------------------------
  attr_accessor :max_escape_count
  attr_accessor :escape_count
  attr_accessor :hide_meters
  attr_accessor :no_active_battler
  #--------------------------------------------------------------------------
  def escape_atb_linetype
    return 2 unless @battle_can_escape
    return 1 if @battle_can_escape
  end
  #--------------------------------------------------------------------------
  def escape_atb_lineamount
    return 100 * @escape_count / @max_escape_count if @battle_can_escape
    return 100 unless @battle_can_escape
  end
  #--------------------------------------------------------------------------
  def max_escape_count
    return @max_escape_count.nil? ? @max_escape_count = 0 : @max_escape_count
  end
  #--------------------------------------------------------------------------
  def escape_count
    return @escape_count.nil? ? @escape_count = 0 : @escape_count
  end
  #--------------------------------------------------------------------------
  def max_escape_count=(n)
    @max_escape_count = n
  end
  #--------------------------------------------------------------------------
  def escape_count=(n)
    @escape_count = n
  end
end

#==============================================================================
# ¦ Game_Battler
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  attr_accessor :cast_action
  attr_accessor :casting
  attr_accessor :cast_target
  attr_accessor :turn_count
  attr_accessor :guarding
  attr_accessor :passed
  attr_accessor :atb_delay
  #--------------------------------------------------------------------------
  alias atoa_initialize_atb initialize
  def initialize
    atoa_initialize_atb
    @cast_skill = @turn_count = @atb_delay = 0
    @guarding = @passed = @casting = false
  end
  #--------------------------------------------------------------------------
  def atb_linetype
    return 4 if self.cast_action != nil and self.atb_full?
    return 3 if self.cast_action != nil
    return 2 if self.atb_full?
    return 1
  end
  #--------------------------------------------------------------------------
  def atb_lineamount
    return 0 if self.dead?
    return 100 * self.atb / self.max_atb
  end
  #--------------------------------------------------------------------------
  def casting
    return false if self.dead?
    return @casting
  end
  #--------------------------------------------------------------------------
  def max_atb
    return Max_Atb
  end
  #--------------------------------------------------------------------------
  def atb
    return @atb.nil? ? @atb = 0 : @atb
  end
  #--------------------------------------------------------------------------
  def atb=(n)
    @atb = [[n.to_i, 0].max, self.max_atb].min
  end
  #--------------------------------------------------------------------------
  def atb_preset
    percent = self.max_atb * Atb_Initial_Rate * (rand(64) + 16) * (self.agi + Atb_Agi_Modifier) / total_agi / 1000
    self.atb = Atb_Initial_Value + percent
  end
  #--------------------------------------------------------------------------
  def total_agi
    total = 0
    for battler in $game_party.actors + $game_troop.enemies
      total += battler.agi
    end
    return total
  end
  #--------------------------------------------------------------------------
  def atb_full?
    return @atb == self.max_atb
  end
  #--------------------------------------------------------------------------
  def atb_update
    if self.cast_action.nil?
      self.atb += speed_adjust * 200 * (self.agi + Atb_Agi_Modifier) / total_agi / 100.0
    else
      cast = cast_action.cast_speed(self)
      self.atb += speed_adjust * (cast + Atb_Agi_Modifier)  / total_agi / 100.0
    end
  end
  #--------------------------------------------------------------------------
  def speed_adjust
    return $game_temp.no_active_battler ? Atb_Speed + 10.0 : Atb_Speed
  end
  #--------------------------------------------------------------------------
  alias atoa_apply_damage_atb apply_damage
  def apply_damage(user, skill = nil)
    effective = atoa_apply_damage_atb(user, skill)
    action = user.now_action
    if action != nil and Cast_Cancel[action.type_name] != nil and
      Cast_Cancel[action.type_name][action.id] != nil
      cancel_cast(Cast_Cancel[action.type_name][action.id], skill)
      if action.type_name == 'Skill' and not action.magic?
        for weapon in weapons
          cancel_cast(Cast_Cancel['Weapon'][weapon.id], skill)
        end
      end
    else
      cancel_cast(Base_Cast_Cancel, skill)
    end
    if action != nil and ATB_Freeze[action.type_name] != nil and
      ATB_Freeze[action.type_name][action.id] != nil
      freeze_action(ATB_Freeze[action.type_name][action.id], skill)
      if action.type_name == 'Skill' and not action.magic?
        for weapon in weapons
          freeze_action(ATB_Freeze['Weapon'][weapon.id], skill)
        end
      end
    else
      freeze_action(Base_ATB_Freeze, skill)
    end
    if action != nil and ATB_Delay[action.type_name] != nil and
      ATB_Delay[action.type_name][action.id] != nil
      delay_action(ATB_Delay[action.type_name][action.id], skill)
      if action.type_name == 'Skill' and not action.magic?
        for weapon in weapons
          delay_action(ATB_Delay['Weapon'][weapon.id], skill)
        end
      end
    else
      delay_action(Base_ATB_Delay, skill)
    end
    return effective
  end
  #--------------------------------------------------------------------------
  def cant_cancel(skill)
    return true if check_include(skill, "NODAMAGE")
    return true if not self.damage.is_a?(Numeric)
    return true if self.damage < 0
    return false
  end
  #--------------------------------------------------------------------------
  def cancel_cast(cast, skill)
    return if cant_cancel(skill)
    rate =  cast + (cast * (self.damage * 50.0 / self.maxhp) / 100.0)
    if rate > rand(100) and self.cast_action != nil
      self.cast_action = nil
      self.atb = 0
    end
  end
  #--------------------------------------------------------------------------
  def delay_action(delay, skill)
    return if cant_cancel(skill)
    rate =  delay + (delay * (self.damage * 50.0 / self.maxhp) / 100.0)
    self.atb -= rate.to_i
  end
  #--------------------------------------------------------------------------
  def freeze_action(delay, skill)
    return if cant_cancel(skill)
    rate =  delay + (delay * (self.damage * 50.0 / self.maxhp) / 100.0)
    self.atb_delay += rate.to_i
  end
end

#==============================================================================
# ¦ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  def inputable?
    return (self.atb_full? and super)
  end
end

#==============================================================================
# ¦ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  def movable?
    return (self.atb_full? and super)
  end
  #--------------------------------------------------------------------------
  def make_action
    self.current_action.clear
    return unless self.movable?
    available_actions = []
    rating_max = 0
    for action in self.actions
      n = @turn_count
      a = action.condition_turn_a
      b = action.condition_turn_b
      next if (b == 0 and n != a) or (b > 0 and (n < 1 or n < a or n % b != a % b))
      next if self.hp * 100.0 / self.maxhp > action.condition_hp
      next if $game_party.max_level < action.condition_level
      switch_id = action.condition_switch_id
      next if switch_id > 0 and $game_switches[switch_id] == false
      next if @sp < calc_sp_cost($data_skills[action.skill_id]) if action.kind == 1
      available_actions << action
      rating_max = action.rating if action.rating > rating_max
    end
    ratings_total = 0
    for action in available_actions
      ratings_total += action.rating - (rating_max - 3) if action.rating > rating_max - 3
    end
    if ratings_total > 0
      value = rand(ratings_total)
      for action in available_actions
        if action.rating > rating_max - 3
          if value < action.rating - (rating_max - 3)
            self.current_action.kind = action.kind
            self.current_action.basic = action.basic
            self.current_action.skill_id = action.skill_id
            self.current_action.decide_random_target_for_enemy
            return
          else
            value -= action.rating - (rating_max - 3)
          end
        end
      end
    end
  end
end

#==============================================================================
# ¦ Game_System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  attr_accessor :wait_mode
  attr_accessor :action_wait
  #--------------------------------------------------------------------------
  alias atoa_initialize_atb initialize
  def initialize
    atoa_initialize_atb
    @wait_mode = Wait_Mode
    @action_wait = Wait_Act_End
  end
end

#==============================================================================
# ¦ Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  attr_accessor :no_active_battler
  #--------------------------------------------------------------------------
  alias atoa_main_atb main
  def main
    turn_count_speed 
    $game_temp.escape_count = 0
    $game_temp.hide_meters = false
    $game_temp.no_active_battler = true
    @escape_type, @escape_name = Escape_Type, Escape_Name
    @input_battlers, @action_battlers = [], []
    @input_battler, @action_battler = nil, nil
    @escaped = @update_turn_end = @action_phase = @freeze_atb = false
    atoa_main_atb
  end
  #--------------------------------------------------------------------------
  alias atoa_start_atb start
  def start
    atoa_start_atb
    for battler in $game_party.actors + $game_troop.enemies
      battler.turn_count = 0
      battler.atb = 0
      battler.atb_preset
      battler.cast_action = nil
      battler.cast_target = nil
      battler.defense_pose = false
    end
  end
  #--------------------------------------------------------------------------
  alias atoa_show_transition_atb show_transition
  def show_transition
    reset_bars
    atoa_show_transition_atb
  end
  #--------------------------------------------------------------------------
  def reset_bars
    @status_window.reset_bars
  end
  #--------------------------------------------------------------------------
  alias atoa_update_atb update
  def update
    if @phase == 1
      $game_temp.battle_main_phase = true
      @actor_command_window.opacity = 0
      @phase = 0
    elsif @phase != 5
      @phase = 0
    end
    check_active_battler
    return $scene = Scene_Gameover.new if $game_temp.gameover
    atoa_update_atb
    return update_phase5 if @phase == 5
    return if $game_system.battle_interpreter.running? and $game_temp.forcing_battler.nil?
    if @update_turn_end
      turn_ending
      @update_turn_end = false
    end
    update_escape
    return if @escaped
    atb_update
    input_battler_update
    action_battler_update
  end
  #--------------------------------------------------------------------------
  def action_battler_update
    if @action_battlers[0] != nil
      @action_battlers.flatten!
      battler = @action_battlers[0]
      battler.atb = 0 if battler.dead?
    end
    update_phase4 unless @spriteset.effect?
  end
  #--------------------------------------------------------------------------
  def check_active_battler
    no_active = (@action_battlers.empty? and @active_battlers.empty? and @input_battlers.empty?)
    $game_temp.no_active_battler = Faster_if_inactive ? no_active : false
  end
  #--------------------------------------------------------------------------
  def input_battler_update
    for battler in $game_party.actors + $game_troop.enemies
      if (battler.atb_full? or $game_temp.forcing_battler == battler) and not
        @action_battlers.include?(battler) and not
        @active_battlers.include?(battler) and not
        @input_battlers.include?(battler)
        battler_turn(battler)
      end
    end
    if @input_battlers[0] != nil and @input_battler.nil? and !wait_on and
      (($game_system.wait_mode == 0 and @active_battlers.empty?) or $game_system.wait_mode > 0)
      @input_battlers.flatten!
      @input_battler = @input_battlers[0]
      if @input_battler.current_action.forcing or @input_battler.confused?
        if @input_battler.confused?
          @input_battler.current_action.kind = 0
          @input_battler.current_action.basic = 0
        end
        battler.defense_pose = false
        @action_battlers << @input_battlers.shift
        @action_battlers.compact!
        @input_battler = nil
      elsif @input_battler.inputable?
        @actor_index = $game_party.actors.index(@input_battler)
        @input_battler.current_action.clear
      else
        @input_battler.atb_update
        @input_battlers.shift
        @input_battler = nil
      end
    end
    if @input_battler != nil
      battler.defense_pose = false
      @input_battler.blink = true
      @active_battler = @input_battler
      if @actor_command_window.opacity == 0
        Audio.se_play('Audio/SE/' + Command_Up_SE) if @active_battler.cast_action.nil? and Command_Up_SE != nil
        phase3_setup_command_window
      end
      update_phase3
    end
    for battler in $game_party.actors + $game_troop.enemies
      next if battler.exist?
      @input_battlers.delete(battler)
      @action_battlers.delete(battler)
    end
  end
  #--------------------------------------------------------------------------
  def update_escape
    if Input.press?(Escape_Input) and @escape_type > 0
      if $game_temp.battle_can_escape
        $game_temp.max_escape_count = update_phase2_escape_rate
        $game_temp.escape_count += 2 unless wait_on
        @escaping = true
        if !@help_window.visible and @escape_type == 1
          @help_window.set_text('')
          @help_window.set_text(Escape_Message, 1)
        end
        if @escape_type == 2
          if @escape_atb_meters.nil?
            @escape_atb_meters = Escape_Meters.new
            @escape_meter_opacity = 0
            @escape_atb_meters.visible = true
          else @escape_atb_meters != nil
            @escape_atb_meters.opacity = 15 * @escape_meter_opacity
            @escape_meter_opacity = [@escape_meter_opacity + 1, 17].min
            @escape_atb_meters.refresh
          end
        end
        if $game_temp.escape_count >= $game_temp.max_escape_count
          $game_temp.escape_count = 0
          update_phase2_escape unless $game_party.all_dead?
        end
      else
        @help_window.set_text(Cant_Escape_Message, 1) if @escape_type == 1       
        if @escape_type == 2     
          if @escape_atb_meters.nil?
            @escape_atb_meters = Escape_Meters.new
            @escape_meter_opacity = 0
            @escape_atb_meters.visible = true
          else @escape_atb_meters != nil
            @escape_atb_meters.opacity = 15 * @escape_meter_opacity
            @escape_meter_opacity = [@escape_meter_opacity + 1, 17].min
            @escape_atb_meters.refresh
          end
        end
      end
    elsif @escape_type > 0
      if @escaping
        @escaping = false
        @help_window.visible = false
      end
      $game_temp.escape_count = [$game_temp.escape_count - 1, 0].max unless wait_on
      if @escape_atb_meters != nil and $game_temp.escape_count == 0
        @escape_atb_meters.opacity = 15 * @escape_meter_opacity
        @escape_meter_opacity = [@escape_meter_opacity - 1, 0].max
        if @escape_meter_opacity == 0
          @escape_atb_meters.dispose
          @escape_atb_meters = nil
        end
      end
      @escape_atb_meters.refresh if @escape_atb_meters != nil
    end
  end
  #--------------------------------------------------------------------------
  def battler_turn(battler)
    battler.turn_count += 1
    if battler.is_a?(Game_Actor)
      if battler.inputable? and battler.cast_action.nil?
        @input_battlers << battler
        @input_battlers.compact!
      else
        if battler.confused?
          battler.current_action.kind = 0
          battler.current_action.basic = 0
        end
        battler.defense_pose = false
        @action_battlers << battler
        @action_battlers.compact!
      end
    else
      if battler.current_action.forcing or $game_temp.forcing_battler
        battler.current_action.forcing = false
        $game_temp.forcing_battler = nil
      else
        battler.make_action
      end
      @action_battlers << battler
      @action_battlers.compact!
    end
  end
  #--------------------------------------------------------------------------
  def atb_update
    update_meters
    return if wait_on
    @atb_turn_count += 1 if Custom_Turn_Count == 2
    if @atb_turn_count >= @abt_turn_speed
      @update_turn_end = true if Slip_Damage_Pop_Time >= 2
      for index in 0...$data_troops[@troop_id].pages.size
        page = $data_troops[@troop_id].pages[index]
        $game_temp.battle_event_flags[index] = false
      end
      $game_temp.battle_turn += 1
      turn_count_speed
      for battler in $game_party.actors + $game_troop.enemies
        battler.remove_states_auto if battler.exist?
      end
      setup_battle_event
    end
    for battler in $game_party.actors + $game_troop.enemies
      unless battler.exist?
        battler.cast_action = nil
        battler.atb = 0
      end
      next if (@escaping and battler.actor? and @escape_type > 0)
      next if battler.restriction == 4 or @active_battlers.include?(battler)
      next unless battler.exist?
      next if Pause_if_Damaged and battler.damaged
      if battler.atb_delay > 0
        battler.atb_delay -= 1
        next
      end
      battler.atb_update
    end
  end
  #--------------------------------------------------------------------------
  def wait_on
    return true if $game_system.wait_mode == 1 and (@skill_window != nil or @item_window != nil)
    return true if $game_system.wait_mode == 0 and @input_battler != nil
    return true if ($game_system.action_wait or @freeze_atb) and not allow_next_action
    return true if @battle_start or @battle_ending or @phase == 5
    return false
  end
  #--------------------------------------------------------------------------
  def start_phase2
  end
  #--------------------------------------------------------------------------
  def update_meters
    @status_window.active_time_update
  end
  #--------------------------------------------------------------------------
  def turn_count_speed
    @atb_turn_count = @abt_turn_speed = 0
    case Custom_Turn_Count
    when 0
      for battler in $game_party.actors + $game_troop.enemies
        @abt_turn_speed += 1 if battler.exist?
      end
    when 1
      @abt_turn_speed = Action_Turn_Count
    when 2
      @abt_turn_speed = Time_Tunr_Count
    end
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape
    windows_dispose
    update_phase2_escape_type1 if @escape_type == 0
    update_phase2_escape_type2 if @escape_type > 0
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_type1
    if rand(100) < set_escape_rate
      command_input_cancel
      @battle_ending = true
      $game_system.se_play($data_system.escape_se)
      $game_system.bgm_play($game_temp.map_bgm)
      battle_end(1)
    else
      @escape_ratio += 3
      phase3_next_actor
    end
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_type2
    @escaped = true
    command_input_cancel
    @battle_ending = true
    $game_system.se_play($data_system.escape_se)
    $game_system.bgm_play($game_temp.map_bgm)
    if @escape_atb_meters != nil
      @escape_atb_meters.dispose
      @escape_atb_meters = nil
    end
    battle_end(1)
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_rate
    enemies_agi = enemies_number = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        enemies_agi += enemy.agi
        enemies_number += 1
      end
    end
    enemies_agi /= [enemies_number, 1].max
    actors_agi = actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        actors_agi += actor.agi
        actors_number += 1
      end
    end
    actors_agi /= [actors_number, 1].max
    escape_rate = Escape_Time * enemies_agi / (actors_agi * Speed)
    return escape_rate
  end
  #--------------------------------------------------------------------------
  alias atoa_set_guard_action_atb set_guard_action
  def set_guard_action(battler)
    atoa_set_guard_action_atb(battler)
    battler.atb = 0
  end
  #--------------------------------------------------------------------------
  alias atoa_set_escape_action_atb set_escape_action
  def set_escape_action(battler)
    atoa_set_escape_action_atb(battler)
    battler.atb = 0
  end
  #--------------------------------------------------------------------------
  alias atoa_set_action_none_atb set_action_none
  def set_action_none(battler)
    atoa_set_action_none_atb(battler)
    battler.atb = 0
    battler.current_phase = 'Phase 6-1'
  end
  #--------------------------------------------------------------------------
  alias atoa_start_phase5_atb start_phase5
  def start_phase5
    @help_window.visible = false if @help_window != nil
    @input_battler.blink = false if @input_battler != nil
    windows_dispose
    @battle_ending = true
    update_meters
    atoa_start_phase5_atb
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase5_atb update_phase5
  def update_phase5
    windows_dispose
    atoa_update_phase5_atb
  end
  #--------------------------------------------------------------------------
  alias atoa_phase3_setup_command_window phase3_setup_command_window
  def phase3_setup_command_window
    return if @escaped
    if @active_battler != nil && @active_battler.cast_action != nil
      @active_battler.blink = false
      return   
    end
    @party_command_window.active = false
    @party_command_window.visible = false
    @actor_command_window.dispose if @actor_command_window != nil
    s1 = $data_system.words.attack
    s2 = $data_system.words.skill
    s3 = $data_system.words.item
    s4 = $data_system.words.guard
    s5 = @escape_name
    if @escape_type == 0
      @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4, s5]) 
    else
      @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4]) 
    end
    command_window_position
    @actor_command_window.back_opacity = Base_Opacity
    @actor_command_window.back_opacity = Base_Opacity
    @actor_command_window.z = 4500
    @active_battler_window.refresh(@active_battler)
    @active_battler_window.visible = Battle_Name_Window
    @active_battler_window.x = Command_Window_Custom_Position[0]
    @active_battler_window.y = Command_Window_Custom_Position[1] - 64
    @active_battler_window.z = 4500
  end
  #--------------------------------------------------------------------------
  def phase3_next_actor
    action_battler = @input_battlers.shift
    @action_battlers << action_battler
    @action_battlers.compact!
    command_input_cancel
    @input_battler = nil
    @actor_index = nil
    @active_battler = nil
  end
  #--------------------------------------------------------------------------
  def phase3_switch_actor
    @input_battler.current_action.clear
    @input_battler.atb = 0 unless @input_battler.passed
    @input_battler.passed = false
    @input_battlers.delete(@input_battler)
    @action_battlers.delete(@input_battler)
    command_input_cancel
    @input_battler = nil
    @actor_index = nil
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_atb update_phase3
  def update_phase3
    if cancel_command?
      if can_act?
        if [2, 3].include?(@input_battler.restriction)
          @input_battler.current_action.kind = 0
          @input_battler.current_action.basic = 0
        end
        @action_battlers << @input_battler
        @action_battlers.compact!
      end
      command_input_cancel
      return
    end
    atoa_update_phase3_atb
  end
  #--------------------------------------------------------------------------
  def cancel_command?
    return false if @input_battler.nil?
    return true if @input_battler.current_action.forcing
    return true if @input_battler.confused?
    return true if @input_battler.restriction == 4
    return true if not $game_party.actors.include?(@input_battler)
    return false
  end
  #--------------------------------------------------------------------------
  def can_act?
    return true if @input_battler.current_action.forcing
    return true if @input_battler.confused?
    return false
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_basic_command_atb update_phase3_basic_command
  def update_phase3_basic_command
    if Input.trigger?(Input::C)
      case @actor_command_window.commands[@actor_command_window.index]
      when @escape_name
        if $game_temp.battle_can_escape == false
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        update_phase2_escape
        return
      end
    end
    if Input.trigger?(Input::UP) and @input_action
      $game_system.se_play($data_system.cursor_se)
      @actor_command_window.index -= 1
      if @actor_command_window.index <= -1 
        @actor_command_window.index = @actor_command_window.commands_size - 1
      end
      return
    end
    if Input.trigger?(Input::DOWN) and @input_action
      $game_system.se_play($data_system.cursor_se)
      @actor_command_window.index += 1
      if @actor_command_window.index >= @actor_command_window.commands_size - 1
        @actor_command_window.index = 0
      end
      return
    end
    if Input.trigger?(Next_Input)
      $game_system.se_play($data_system.decision_se)
      @input_battler.passed = true
      phase3_switch_actor
      return
    end
    if Input.trigger?(Cancel_Input)
      $game_system.se_play($data_system.decision_se)
      phase3_switch_actor
      return
    end
    return if Input.trigger?(Next_Input) or Input.trigger?(Cancel_Input)
    atoa_update_phase3_basic_command_atb
  end
  #--------------------------------------------------------------------------
  def command_input_cancel
    windows_dispose
    @input_battler.blink = false
    @input_battlers.delete(@input_battler)
    @input_battler = nil
  end
  #--------------------------------------------------------------------------
  def windows_dispose
    @help_window.visible = false if !@escaping
    if @enemy_arrow != nil
      @enemy_arrow.dispose
      @enemy_arrow = nil
    end
    if @actor_arrow != nil
      @actor_arrow.dispose
      @actor_arrow = nil
    end
    if @actor_arrow != nil
      @actor_arrow.dispose
      @actor_arrow = nil
    end
    if @skill_window != nil
      @skill_window.dispose
      @skill_window = nil
    end
    if @item_window != nil
      @item_window.dispose
      @item_window = nil
    end
    if @enemy_arrow_all != nil
      @enemy_arrow_all.dispose_multi_arrow
      @enemy_arrow_all = nil
    end
    if @actor_arrow_all != nil
      @actor_arrow_all.dispose_multi_arrow
      @actor_arrow_all = nil
    end
    if @battler_arrow_all != nil
      @battler_arrow_all.dispose_multi_arrow
      @battler_arrow_all = nil
    end
    if @actor_command_window != nil
      @actor_command_window.active = false
      @actor_command_window.visible = false
      @active_battler_window.visible = false
      @actor_command_window.opacity = 0
    end
    @status_window.visible = true
  end
  #-------------------------------------------------------------------------- 
  alias atoa_step2_part1_atb step2_part1
  def step2_part1(battler)
    battler.defense_pose = false
    if battler.cast_action != nil
      active_cast = battler.cast_action
      if active_cast.scope == 1 or active_cast.scope == 3 or active_cast.scope == 5
        battler.current_action.target_index = battler.cast_target
      end
      if active_cast.is_a?(RPG::Skill)
        battler.current_action.kind = 1
        battler.current_action.skill_id = battler.cast_action.id
      elsif active_cast.is_a?(RPG::Item) 
        battler.current_action.kind = 2
        battler.current_action.item_id = battler.cast_action.id
      end
    end
    atoa_step2_part1_atb(battler)
    if (battler.now_action.is_a?(RPG::Skill) or battler.now_action.is_a?(RPG::Item)) and
      battler.cast_action.nil?
      battler.cast_action = battler.now_action
      battler.cast_target = battler.current_action.target_index
      cast_speed = battler.now_action.cast_speed(battler)
      battler.cast_action = nil if cast_speed == 0
      unless cast_speed == 0
        battler.movement = false
        battler.current_phase = 'Phase 6-1'
      end
    end
    if cant_use_action(battler) and battler.cast_action != nil
      battler.cast_action = nil
      battler.moviment = false
      battler.current_phase = 'Phase 6-1'
    end
    battler.atb = 0 unless battler.passed
    battler.passed = false
  end
  #--------------------------------------------------------------------------
  alias atoa_step3_part1_atb step3_part1
  def step3_part1(battler)
    atoa_step3_part1_atb(battler)
    battler.cast_action = nil
    @freeze_atb = check_include(battler_action(battler), 'FREEZEATB')
  end
  #--------------------------------------------------------------------------
  alias atoa_step6_part5_atb step6_part5
  def step6_part5(battler)
    atoa_step6_part5_atb(battler)
    @atb_turn_count += 1 unless Custom_Turn_Count == 2
    @input_battlers.delete(battler)
    @action_battlers.delete(battler)
    @action_battler = nil
    @freeze_atb = false
    update_meters
    judge
  end
end

#==============================================================================
# ¦ Sprite_Battler
#==============================================================================
class Sprite_Battler < RPG::Sprite
  #--------------------------------------------------------------------------
  alias atoa_set_pose_atb set_pose
  def set_pose
    pose = atoa_set_pose_atb
    unless pose == Dead_Pose or pose == Victory_Pose
      if battler.cast_action != nil
        action = @battler.cast_action
        cast_pose = set_pose_id('Chanting')
        ext = check_extension(action, 'CHANTING/')
        if ext != nil
          ext.slice!('CHANTING/')
          cast_pose = ext.to_i
        end
      end
    end
    return cast_pose.nil? ? pose : cast_pose
  end
end

#==============================================================================
# ¦ Window_Command
#==============================================================================
class Window_Command < Window_Selectable
  #--------------------------------------------------------------------------
  attr_accessor :commands
  #--------------------------------------------------------------------------
  def commands_size
    return @item_max
  end
end

#==============================================================================
# Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  alias atb_battle_status_initialize initialize
  def initialize
    @atb_meters = ATB_Meters.new if Meters
    @enm_meters = Enemy_Meters.new if Enemy_Meter > 0
    @atb_bars = ATB_Bars.new if Bars
    @alive_enemies = enemies_alive
    @old_party = $game_party.actors
    atb_battle_status_initialize
  end
  #--------------------------------------------------------------------------
  alias atb_battle_status_refresh refresh
  def refresh
    atb_battle_status_refresh
    active_time_update
  end
  #--------------------------------------------------------------------------
  alias face_anim_visible visible=
  def visible=(n)
    face_anim_visible(n)
    need_reset
    @atb_meters.visible = n  if Hide_Meters and @atb_meters != nil
    @enm_meters.visible = n if Hide_Meters and @enm_meters != nil
    @atb_bars.visible = n if Hide_Bars and @atb_bars != nil
  end
  #--------------------------------------------------------------------------
  alias atb_battle_status_dispose dispose
  def dispose
    atb_battle_status_dispose
    @atb_meters.dispose if @atb_meters != nil
    @enm_meters.dispose if @enm_meters != nil
    @atb_bars.dispose if @atb_bars != nil
  end
  #--------------------------------------------------------------------------
  def active_time_update
    need_reset
    @atb_meters.refresh if @atb_meters != nil
    @enm_meters.refresh if @enm_meters != nil
    @atb_bars.refresh if @atb_bars != nil
  end
  #--------------------------------------------------------------------------
  def need_reset
    if (@alive_enemies != enemies_alive) or (@old_party != $game_party.actors)
      @alive_enemies = enemies_alive
      @old_party = $game_party.actors
      reset_bars
    end
  end
  #--------------------------------------------------------------------------
  def enemies_alive
    alive = 0
    for i in 0...$game_troop.enemies.size
      alive += 1 unless $game_troop.enemies[i].dead?
    end
    return alive
  end
  #--------------------------------------------------------------------------
  def reset_bars
    @atb_meters.dispose if @atb_meters != nil
    @enm_meters.dispose if @enm_meters != nil
    @atb_bars.dispose if @atb_bars != nil
    @atb_meters = ATB_Meters.new if Meters
    @enm_meters = Enemy_Meters.new if Enemy_Meter > 0
    @atb_bars = ATB_Bars.new if Bars
  end
end

#==============================================================================
# ¦ ATB_Meters
#==============================================================================
class ATB_Meters
  #--------------------------------------------------------------------------
  attr_accessor :meters
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  def initialize
    @meters = []
    @skin = RPG::Cache.windowskin(Meter_Skin)
    i = 0
    for actor in $game_party.actors
      @meter = MeterSprite.new(@skin, 5)
      refresh_meter(i)
      i += 1
    end
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    i = 0
    for actor in $game_party.actors
      @meters[i].line = actor.atb_linetype
      @meters[i].amount = actor.atb_lineamount
      @meters[i].atb_visible = true
      i += 1
    end
  end
  #--------------------------------------------------------------------------
  def refresh_meter(i)
    actor = $game_party.actors[i]
    case Meter_Pos_Style
    when 0
      @meter.x = i * (624 / Max_Party) + 4 + X_Meter
      @meter.y = Y_Meter
      @meter.z = 1000
    when 1
      @meter.x = X_Meter + ((624 / Max_Party) * ((4 - $game_party.actors.size)/2.0 + i)).floor
      @meter.y = Y_Meter
      @meter.z = 1000
    when 2
      @meter.x = X_Meter
      @meter.y = i * 32 + Y_Meter
      @meter.z = 1000
    when 3
      @meter.x = actor.base_x - @skin.width / 2
      @meter.y = actor.base_y - @skin.height / 5
      @meter.z = @meter.y
    when 4
      @meter.x = actor.base_x - @skin.width / 2
      @meter.y = actor.base_y - @skin.height / 5 - 64
      @meter.z = 2500
    when 5
      base = Meter_Position[i]
      @meter.x = base[0]
      @meter.y = base[1]
      @meter.z = 2500
    end
    @meters[i] = @meter
  end
  #--------------------------------------------------------------------------
  def visible=(b)
    @meters.each{|sprite| sprite.visible = b }
  end
  #--------------------------------------------------------------------------
  def opacity=(b)
    @meters.each{|sprite| sprite.opacity = b }
  end
  #--------------------------------------------------------------------------
  def dispose
    @meters.each{|sprite| sprite.dispose }
  end
end

#==============================================================================
# ¦ Enemy_Meters
#==============================================================================
class Enemy_Meters
  #--------------------------------------------------------------------------
  attr_accessor :meters
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  def initialize
    @meters = {}
    @skin = RPG::Cache.windowskin(Meter_Skin)
    for enemy in $game_troop.enemies
      next if enemy.dead?
      @meter = MeterSprite.new(@skin, 5)
      refresh_meter(enemy)
    end
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    for enemy in $game_troop.enemies
      next if enemy.dead?
      @meters[enemy].line = enemy.atb_linetype
      @meters[enemy].amount = enemy.atb_lineamount
      @meters[enemy].atb_visible = true
    end
  end
  #--------------------------------------------------------------------------
  def refresh_meter(enemy)
    case Enemy_Meter
    when 1
      @meter.x = enemy.base_x - @skin.width / 2
      @meter.y = enemy.base_y - @skin.height / 5
      @meter.z = @meter.y
    when 2
      @meter.x = enemy.base_x - @skin.width / 2
      @meter.y = enemy.base_y - @skin.height / 5 - 64
      @meter.z = 1000
    when 3
      @meter.x = 32
      @meter.y = 80 + enemy.index * 32
      @meter.z = 3000
    end
    @meters[enemy] = @meter
  end
  #--------------------------------------------------------------------------
  def visible=(b)
    @meters.keys.each{|sprite| @meters[sprite].visible = b }
  end
  #--------------------------------------------------------------------------
  def opacity=(b)
    @meters.keys.each{|sprite| @meters[sprite].opacity = b }
  end
  #--------------------------------------------------------------------------
  def dispose
    @meters.keys.each{|sprite| @meters[sprite].dispose }
  end
end

#==============================================================================
# ¦ ATB_Bars
#==============================================================================
class ATB_Bars
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  def initialize
    @base = Sprite.new
    @base.bitmap = RPG::Cache.windowskin(Bar_Skin).dup
    @base.x = X_Bar
    @base.y = Y_Bar
    @base.z = 3000
    @width  = @base.bitmap.width
    @height = @base.bitmap.height
    @iconset = []
    @base.opacity = self.opacity = 255
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    return @base.opacity = self.opacity = 0 unless Bars
    need_refresh = []
    for battler in $game_party.actors + $game_troop.enemies
      exist = false
      for set in @iconset
        exist |= (set[1] == battler)
      end
      need_refresh << battler unless exist
    end
    for battler in need_refresh
      iconname = nil
      if battler.is_a?(Game_Actor)
        iconname = Party_Icon[battler.battler_name]
      else
        iconname = Enemy_Icon[battler.battler_name]
      end
      if iconname.nil?
        if battler.is_a?(Game_Actor)
          iconname = Default_Party_Icon
        else
          iconname = Default_Enemy_Icon
        end
      end
      icon = Sprite.new
      icon.bitmap = RPG::Cache.icon(iconname).dup
      icon.y = Y_Bar + @height / 2 - 12
      @iconset << [icon, battler] unless @iconset.include?([icon, battler])
    end
    for icon in @iconset
      icon[0].x = X_Bar + @width * icon[1].atb / icon[1].max_atb - 12
      icon[0].z = 3001
      icon[0].visible = icon[1].exist?
      icon[0].opacity = icon[1].exist? ? 255 : 0
    end
    self.visible = $game_temp.hide_windows ? false : true
  end
  #--------------------------------------------------------------------------
  def visible=(n)
    @base.visible = n
    for icon in @iconset
      icon[0].visible = n
    end
  end
  #--------------------------------------------------------------------------
  def opacity=(n)
    @base.opacity = n
    for icon in @iconset
      icon[0].opacity = n
    end
  end
  #--------------------------------------------------------------------------
  def dispose
    @base.dispose
    for icon in @iconset
      icon[0].dispose
    end
  end
end

#==============================================================================
# ¦ Escape_Meters
#==============================================================================
class Escape_Meters
  #--------------------------------------------------------------------------
  attr_accessor :meters
  attr_reader  :meters
  attr_accessor :enemy_meters
  attr_reader  :enemy_meters
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  def initialize
    @skin = RPG::Cache.windowskin(Escape_Skin)
    @escape_meter = MeterSprite.new(@skin, 3)
    refresh_meter
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    @escape_meter.line  = $game_temp.escape_atb_linetype
    @escape_meter.amount = $game_temp.escape_atb_lineamount
    @escape_meter.z = 5000
  end
  #--------------------------------------------------------------------------
  def refresh_meter
    case Escape_Meter_Pos_Type
    when 0
      @escape_meter.x = 608 - @skin.width
      @escape_meter.y = 80
    when 1
      @escape_meter.x = 320 - skin.width
      @escape_meter.y = 64
    when 2
      @escape_meter.x = Escape_Meter_Position[0]
      @escape_meter.y = Escape_Meter_Position[1]
    end
    @escape_meter.z = 5000
  end
  #--------------------------------------------------------------------------
  def visible=(n)
    @escape_meter.visible = n
  end
  #--------------------------------------------------------------------------
  def opacity=(n)
    @escape_meter.opacity = n
  end
  #--------------------------------------------------------------------------
  def dispose
    @escape_meter.dispose
  end
end

#==============================================================================
# ¦ MeterSprite
#==============================================================================
class MeterSprite < Sprite
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  def initialize(skin, line_height)
    @line_height = line_height
    @skin  = skin
    @width  = @skin.width
    @height = @skin.height / @line_height
    @line  = 1
    @amount = 0
    @atb_visible = false
    @base_sprite.dispose if @base_sprite != nil
    viewport = [3,4].include?(Meter_Pos_Style) ? $game_temp.battlers_viweport : nil
    @base_sprite = Sprite.new(viewport)
    @base_sprite.bitmap = @skin
    @base_sprite.src_rect.set(0, 0, @width, @height)
    super(viewport)
    self.bitmap = @skin
    self.line = 1
    self.opacity = 0 if @line_height == 3
  end
  #--------------------------------------------------------------------------
  def line=(n)
    @line = n
    refresh
  end
  #--------------------------------------------------------------------------
  def amount=(n)
    @amount = n
    refresh
  end
  #--------------------------------------------------------------------------
  def visible=(n)
    @base_sprite.visible = n
    super
  end
  #--------------------------------------------------------------------------
  def opacity=(n)
    @base_sprite.opacity = n
    super
  end
  #--------------------------------------------------------------------------
  def atb_visible=(n)
    @atb_visible = n
    refresh
  end
  #--------------------------------------------------------------------------
  def refresh
    self.src_rect.set(0, @line * @height, @width * @amount / 100, @height)
  end
  #--------------------------------------------------------------------------
  def x=(n)
    super
    @base_sprite.x = n
  end
  #--------------------------------------------------------------------------
  def y=(n)
    super
    @base_sprite.y = n
  end
  #--------------------------------------------------------------------------
  def z=(n)
    super
    @base_sprite.z = z - 1
  end
  #--------------------------------------------------------------------------
  def dispose
    @base_sprite.dispose
    super
  end
end

Speed = 5 #Integer value, coba" aja berapa

@input_battler.blink = false

@active_battler = @input_battler

@input_battler.blink=false if @input_battler != nil