STABS reorganization & upgrade

#===============================================================================
# Z3 Simple TActical Battle System (S.T.A.B.S.)
# By Zetu
# Permission required for commercial games
#===============================================================================
# Overwritten Methods:
# None
#-------------------------------------------------------------------------------
# Aliased methods:
# None
#===============================================================================
# Introduction :
#   STABS is a simple tactical battle system for VXAce.
#===============================================================================

$imported ||= {}
$imported["Z3S-STABS"] = true

module Z3S
  module STABS

#==============================================================================
# Battle Setting
#------------------------------------------------------------------------------
    RecoverAfterBattle   = true
    ShowStatesForEnemies = false
    MaxParty             = 3

#==============================================================================
# Vocab Setting
#------------------------------------------------------------------------------

    MoveCmd  = "Move to location!"
    ItemCmd  = "Use an Item from your Inventory!"
    SkillCmd = "Use a %s skill!"


#==============================================================================
# Color Setting
#------------------------------------------------------------------------------
    ColorMove      = Color.new(102, 204, 0)
    ColorPhysical  = Color.new(255, 51, 51)
    ColorMagic     = Color.new(51, 153, 0)
    ColorPlacement = Color.new(255, 51, 51)
    ColorSelected  = Color.new(255, 255, 102)

#===============================================================================
# END CUZTOMIZATION
#===============================================================================
  end
end

#==============================================================================
# ■ BattleManagerII
#==============================================================================
module BattleManagerII

  #----------------------------------------------------------------------------
  # ○ new method: battle_start
  #----------------------------------------------------------------------------
   def self.battle_start(map_id, enable_continue)
      @old_game_map = $game_map
      @x = $game_player.x
      @y = $game_player.y
      $game_map = Game_BattleMap.new
      $game_map.setup(map_id, enable_continue)
      $game_player.refresh
      SceneManager.scene.start_stabs_scene
      $game_party.on_battle_start
    end

  #----------------------------------------------------------------------------
  # ○ new method: battle_end
  #----------------------------------------------------------------------------
    def self.battle_end(win)
      @last_result = win
      $game_map = @old_game_map
      $game_player.moveto(@x, @y)
      SceneManager.scene.spriteset.remove_stabs
      $game_party.on_battle_end
      $game_player.refresh
    end

   def self.play_victory_me
     $game_system.battle_end_me.play
   end

end
#==============================================================================
# ■ DataManager
#==============================================================================
module DataManager

  #----------------------------------------------------------------------------
  # ● alias method:
  #----------------------------------------------------------------------------
  class << self
   alias :stabs_loadnd :load_normal_database
  end


  #----------------------------------------------------------------------------
  # ● alias method: load_normal_database
  #----------------------------------------------------------------------------
  def self.load_normal_database
    stabs_loadnd
    extract_stabs_data.each do |obj|
      if obj
        obj.add_stabs
      end
    end

  end


  #----------------------------------------------------------------------------
  # ○ new method: extract_stabs_data
  #----------------------------------------------------------------------------
  def self.extract_stabs_data
    @actors   = $data_actors  # actor_id in the database
    @classes  = $data_classes # classes_id in the database
    @skills   = $data_skills  # skill_id in the database
    @items    = $data_items   # item_id in the database
    @weapons  = $data_weapons # weapon_id in the database
    @armors   = $data_armors  # armor_id in the database
    @enemies  = $data_enemies # enemy_id in the database
    @states   = $data_states  # state_id in the database

  #(BAD WAY!  # $data_actors + $data_classes + $data_skills + $data_items +
    #$data_weapons + $data_armors + $data_enemies + $data_states)
    # Explaination : your way of doing this work, but make all this stuff
    # unreadable and to much compact
  end


end

#==============================================================================
# ■ RPG::BaseItem
#==============================================================================
class RPG::BaseItem

  #----------------------------------------------------------------------------
  # ○ new method: add_stabs
  #----------------------------------------------------------------------------
  def add_stabs

  end

  #----------------------------------------------------------------------------
  # ○ new method: add_int
  #----------------------------------------------------------------------------
  def add_int(regex, default = 0)
    @note.scan(regex).each do
      return $1.to_i
    end
    return default
  end

end
#==============================================================================
# ■ RPG::State
#==============================================================================
class RPG::State < RPG::BaseItem
  attr_reader :_s_sci

  #----------------------------------------------------------------------------
  # ○ new method: add_stabs
  #----------------------------------------------------------------------------
  def add_stabs
    super
    @_s_sci = add_int(/<special_index[:\s]*(\d)>/i, -1)
  end

end
#==============================================================================
# ■ Game_Interpreter
#==============================================================================
class Game_Interpreter

  #----------------------------------------------------------------------------
  # ○ new method: stabs_start
  #----------------------------------------------------------------------------
  def stabs_start(map_id, enable_continue = false)
    BattlerManagerII.battle_start(map_id, enable_continue)
  end

  #----------------------------------------------------------------------------
  # ○ new method: add_enemy
  #----------------------------------------------------------------------------
  def add_enemy(enemy_id, x, y)
    @last_event = $game_map.add_enemy(enemy_id, x, y)
  end

  #----------------------------------------------------------------------------
  # ○ new method: add_enemy_here
  #----------------------------------------------------------------------------
  def add_enemy_here(enemy_id)
    event = $game_map.events[@event_id]
    @last_event = $game_map.add_enemy_here(enemy_id, event)
  end

end
#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map

  #----------------------------------------------------------------------------
  # ○ new method: in_battle?
  #----------------------------------------------------------------------------
  def in_battle?
    return false
  end

  #----------------------------------------------------------------------------
  # ○ new method: mode
  #----------------------------------------------------------------------------
  def mode
   return :null
  end

  #----------------------------------------------------------------------------
  # ○ new method: phase
  #----------------------------------------------------------------------------
  def phase
   return :null
  end

end
#==============================================================================
# ■ Game_BattleMap
#==============================================================================
class Game_BattleMap < Game_Map

  attr_reader   :enable_continue
  attr_reader   :party_events
  attr_reader   :enemy_events
  attr_reader   :animated_target
  attr_reader   :targets
  attr_reader   :user
  attr_reader   :item
  attr_reader   :action_list
  attr_reader   :dummy_event

  attr_accessor :mode
  attr_accessor :phase
  attr_accessor :on_ok
  attr_accessor :on_cancel

  def setup(map_id, enable_continue)
    super(map_id)
    BattleManager.save_bgm_and_bgs
    BattleManager.play_battle_bgm
    @party_events = []
    @enemy_events = []
    @action_list = Stabs_ActionList.new
    @enable_continue = enable_continue
    $game_player.refresh
  end

  def finalize
    @all_party_members = party_members
    @all_enemy_members = enemy_members
    $game_troop.enemies = @all_enemy_members
  end

  def set(phase, mode, ok = nil, cancel = nil)
    @phase     = phase
    @mode      = mode
    @on_ok     = ok
    @on_cancel = cancel
  end

  def battle_active?
    return false if @phase == :wait_for_placement
    return false if @phase == :wait_for_victory
    return true
  end

  def victory?
    enemy_members.each do |enemy|
      return false if !enemy.restriction != 4
    end
    return true
  end

  def loss?
    false
  end

  def setup_events
    super
    @events.values.each do |event|
      event.reset_self_switches
    end
    for y in 0...$game_map.height
      for x in 0...$game_map.width
        if region_id(x, y) == 61
          e = add_new_event(x, y)
          e.event.name = "Placement"
        end
      end
    end
    @dummy_event = add_new_event(0,0)
  end

  def add_new_event(x, y, battler = nil)
    for i in 1..99999
      next if @events[i]
      de = RPG::Event.new(0, 0)
      de.pages[0].priority_type = 1
      de.id = i
      @events[i] = Game_Event.new(@map_id, de)
      @events[i].moveto(x, y)
      @events[i].battler = battler
      SceneManager.scene.spriteset.add_event(@events[i])
      return @events[i]
      return nil
    end
  end

  def disable_dash?
    true
  end

  def encounter_list
    []
  end

  def overworld?
    false
  end

  def in_battle?
    true
  end

  def add_actor_event(event, actor)
    event.battler = actor
    @party_events.push(event)
    event.set_battler_graphic(actor)
  end

  def remove_actor_event(event)
    @party_events.delete(event)
    event.battler = nil
  end

  def add_enemy(enemy_id, x, y)
    e = add_new_event(x, y, Game_Enemy.new(@enemy_events.size, enemy_id))
    @enemy_events.push(e)
    e.set_battler_graphic(e.battler)
    return setup_enemy(e)
  end

  def add_enemy_here(enemy_id, event)
    event.battler = Game_Enemy.new(@enemy_events.size, enemy_id)
    return setup_enemy(event)
  end

  def setup_enemy(event)
    @enemy_events.push(event)
    event.set_battler_graphic(event.battler)
    event.refresh
    return event
  end

  def delete_event(event)
    remove_event(event)
    SceneManager.scene.spriteset.delete_event(event)
  end

  def remove_event(event)
    @party_events.delete(event)
    @enemy_events.delete(event)
    SceneManager.scene.battler_order.delete(event.battler)
    @events.delete(event.event.id)
  end

  def party_members
    @party_events.collect do |event| event.battler end
  end

  def enemy_members
    @enemy_events.collect do |event| event.battler end
  end

  def battle_members
    party_members | enemy_members
  end

  def allow_char_select?
    @mode == :free
  end

  def battler_event_xy(x, y)
    events_xy(x, y).each do |event|
      if event.battler
        return event
      end
    end
    return nil
  end

  def battler_xy(x, y)
    e = battler_event_xy(x, y)
    e ? e.battler : nil
  end

  def in_animation?
    $game_map.battle_members.each do |battler|
      return true if battler.event.animation_id != 0
    end
    return false
  end

  def item_apply(user, item, targets, weapon_slot = -1)
    @user    = user
    @item    = item
    @targets = targets
    show_animation(targets, item.animation_id)
    user.event.turn_toward_player# if item.need_selection?
    SceneManager.scene.wait_for_effects
    battle_members.each do |battler|
      if targets.include?(battler)
        battler.item_apply(user, item)
        SceneManager.scene.show_results(battler, item)
      end
    end
    set(:wait_for_collapse, :fixed)
  end



  def show_animation(targets, animation_id)
    if animation_id < 0
      show_attack_animation(targets)
    else
      show_normal_animation(targets, animation_id)
    end
  end

  def show_attack_animation(targets)
    if @user.actor?
      show_normal_animation(targets, @user.atk_animation_id1)
    else
      Sound.play_enemy_attack
    end
  end

  def show_normal_animation(targets, animation_id)
    animation = $data_animations[animation_id]
    if animation
      targets.each do |target|
        target.event.animation_id = animation_id
      end
    end
  end

  def animation_clear?
    return true unless @animated_target

  end

end
#==============================================================================
# ■ Game_BattlerBase
#==============================================================================
class Game_BattlerBase
  attr_accessor :event

  def stabs_move
    4
  end

  def tp
    100
  end

  def ally(battler)
    $game_map.party_members.include?(self) ==
    $game_map.party_members.include?(battler)
  end

  def leave_corpse?
    false
  end

  def perform_collapse_effect
    if !leave_corpse?
      @event.set_collapse
      $game_map.remove_event(self.event)
    end
  end

  def stabs_battler?
    self.actor?
  end

  def make_actions_list
    Stabs_ActionList.generate(self)
  end

end
#==============================================================================
# ■ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler

  def max_tp
    0
  end

  alias :stabs_pce :perform_collapse_effect
  def perform_collapse_effect
    $game_map.in_battle? ? super : stabs_pce
  end

  def auto_battle?
    true
  end

end
#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler

  def leave_corpse?
    true
  end

  alias :stabs_pce :perform_collapse_effect
  def perform_collapse_effect
    $game_map.in_battle? ? super : stabs_pce
  end

  def drop_weapon(slot_id)
    if @equips[slot_id].is_weapon?
      @equips[slot_id].set_equip(true, 0)
    end
  end

end
#==============================================================================
# ■ Game_Troop
#==============================================================================
class Game_Troop < Game_Unit
  attr_accessor :enemies
end
#==============================================================================
# ■ Scene_Map
#==============================================================================
class Scene_Map < Scene_Base
  attr_reader :spriteset, :selector, :battler_order, :log_window

  def start_stabs_scene
    @spriteset.setup_stabs_sprites
    @selector = Stabs_Selector.new
    @spriteset.sprite_field.selector = @selector
    @selector.get_placement
    @spriteset.set_new_rect(:placement)
    moveto_nexthashstarter
    $game_map.set(:wait_for_placement,:fixed,:selection_placement,:selection_cancel)
    create_initial_windows
    disable_all_windows
    @placecommand_window.show.activate
  end

  alias :stabs_t :terminate
  def terminate
    stabs_t
    perform_battle_transition if SceneManager.scene_is?(Scene_Map) and
    $game_map.in_battle?
  end

  def invoke(symbol)
    return if symbol == nil
    send(symbol)
  end

  def xy
    return $game_player.x, $game_player.y
  end

  def moveto_nexthashstarter
    px = $game_player.x
    py = $game_player.y
    $game_map.height.times do |y|
      $game_map.width.times do |x|
        next unless @selector.include?(x, y)
        unless @selector.include?(px, py)
          $game_player.moveto(x, y)
          return
        end
        event = $game_map.events_xy(x, y)[0]
        next unless event.name =~ /Placement/
        next if event.battler
        $game_player.moveto(x, y)
        return
      end
    end
  end

  def create_initial_windows
    @help_window = Window_Help.new
    @placecommand_window = Window_PlaceCommand.new
    @placecommand_window.set_handler(:actor,   method(:actor_place))
    @placecommand_window.set_handler(:start,   method(:start_battle_confirmation))
    @placecommand_window.set_handler(:cancel,  method(:placement_cancel))
    @confirmation_window = Window_BattleConfirmation.new
    @confirmation_window.set_handler(:start, method(:start_battle))
    @confirmation_window.set_handler(:back,  method(:return_to_placement))
    @confirmation_window.center
    @actorcommand_window = Window_STABSActorCommand.new(@help_window)
    @actorcommand_window.set_handler(:move,    method(:cmd_move))
    @actorcommand_window.set_handler(:use_ext, method(:cmd_use_ext))
    @actorcommand_window.set_handler(:skill,   method(:cmd_skill))
    @actorcommand_window.set_handler(:item,    method(:cmd_item))
    @actorcommand_window.set_handler(:wait,    method(:cmd_wait))
    @log_window = Window_BattleLog.new
    @log_window.method_wait = method(:wait)
    @skill_window = Window_StabsSkill.new(@help_window)
    @skill_window.set_handler(:ok, method(:use_skill_ext))
    @skill_window.set_handler(:cancel, method(:open_battler_commands))
  end

  def disable_all_windows
    instance_variables.each do |varname|
      ivar = instance_variable_get(varname)
      next if ivar.is_a?(Window_BattleLog)
      next if ivar.is_a?(Window_Message)
      ivar.hide.deactivate if ivar.is_a?(Window)
    end
  end

  def actor_place
    event = Game_Event.get($game_map.events_xy(*xy), /Placement/)
    battler = @placecommand_window.current_ext
    $game_map.add_actor_event(event, battler)
    moveto_nexthashstarter
    @placecommand_window.activate.refresh
    if $game_map.party_members.size >= Z3S::STABS::MaxParty
      start_battle_confirmation
    end
    @placecommand_window.index += 1
  end

  def start_battle_confirmation
    disable_all_windows
    @confirmation_window.show.activate
  end

  def placement_cancel
    disable_all_windows
    $game_map.mode = :free
  end

  def cmd_move
    disable_all_windows
    $game_map.set(:wait_for_move, :free, :move_to_xy, :open_battler_commands)
    @selector.get_move_path(active_battler.event)
    @spriteset.set_new_rect(:move)
  end

  def cmd_use_ext
    disable_all_windows
    set_active_skill(@actorcommand_window.current_ext)
  end

  def cmd_wait
    disable_all_windows
    next_battler
  end

  def use_skill_ext
    disable_all_windows
    set_active_skill(@skill_window.item)
  end

  def cmd_item
    @actorcommand_window.activate
  end

  def cmd_skill
    disable_all_windows
    @help_window.activate
    @skill_window.actor = active_battler
    @skill_window.stype_id = @actorcommand_window.current_ext
    @skill_window.refresh
    @skill_window.activate.show
  end

  def show_results(battler, item)
    $game_player.moveto(battler.event.x, battler.event.y)
    @log_window.display_action_results(battler, item)
    wait_for_effects
  end

  def set_active_skill(skill)
    @active_skill = skill
    @selector.set_skill(active_battler.event, skill)
    if skill.need_selection?
      $game_map.set(nil, :free, :skill_selection, :open_battler_commands)
    else
      $game_map.item_apply(active_battler, skill, @selector.targets)
      post_item_apply
    end
  end

  def disable_skill
    @active_skill = nil
  end

  def start_battle
    disable_all_windows
    $game_map.phase = nil
    $game_map.finalize
    @spriteset.clear_all_rect
    init_battler_order
    get_next_battler
  end

  def init_battler_order
    @battler_order = $game_map.battle_members.compact.sort do |b1, b2|
      b2.agi <=> b1.agi
    end
    @active_battler = @battler_order[0]
  end

  def start_turn
    active_battler.event.clear_stabs
    @log_window.display_current_state(active_battler)
    @log_window.wait_and_clear
    if active_battler.restriction == 4
      next_battler
    elsif active_battler.auto_battle?
      determine_auto_command
    else
      activate_active_battler
    end
  end

  def turn_end
    active_battler.on_turn_end
    active_battler.on_action_end
    @log_window.display_auto_affected_status(active_battler)
    @log_window.wait_and_clear
    alter_turn_base
  end

  def active_battler
    @battler_order ? @battler_order[0] : nil
  end

  def next_battler
    turn_end
    get_next_battler
  end

  def get_next_battler
    @active_battler = @battler_order[0]
    @actorcommand_window.index = 0
    start_turn
  end

  def alter_turn_base
    last_active_battler = @battler_order.shift
    @battler_order.push last_active_battler
  end

  def move_battler(battler, x, y)
    $game_map.mode = :fixed
    active_battler.event.move_toward_xy(x, y)
    @target_x = x
    @target_y = y
  end

  def activate_active_battler
    @spriteset.clear_all_rect
    b = active_battler.event
    $game_player.moveto(b.x, b.y)
    open_battler_commands
  end

  def determine_auto_command
    @spriteset.clear_all_rect
    open_battler_commands
  end

  def open_battler_commands
    disable_all_windows
    @spriteset.set_new_rect(:clear)
    x = active_battler.event.x
    y = active_battler.event.y
    $game_player.moveto(x, y)
    @actorcommand_window.battler = active_battler
    @actorcommand_window.show.activate
    @help_window.show.activate
    @actorcommand_window.refresh
    $game_map.mode  = :fixed
    $game_map.phase = nil
  end

  def return_to_placement
    disable_all_windows
    $game_map.mode = :free
  end

  def move_to_xy
    if @selector.include?(*xy)
      active_battler.event.stabs_moves += 1
      move_battler(active_battler, *xy)
    elsif active_battler.event.pos?(*xy)
      activate_active_battler
    else
      Sound.play_buzzer
    end
  end

  def skill_selection
    if @selector.include?(*xy) and
      (targets=@selector.get_targets(*xy)).size != 0
      $game_map.item_apply(active_battler, @active_skill, targets)
      post_item_apply
    else
      Sound.play_buzzer
    end
  end

  def stabs_confirm
    invoke($game_map.on_ok)
  end

  def stabs_cancel
    invoke($game_map.on_cancel)
  end

  def post_item_apply
    @selector.last_targets.each do |user|
      next unless rand < user.item_cnt(active_battler, @active_skill)
      attack_skill = $data_skills[user.attack_skill_id]
      t_selector = Stabs_Selector.new
      t_selector.set_skill(user.event, attack_skill)
      next unless t_selector.targets.include?(active_battler)
      @log_window.display_counter(user, attack_skill)
      ts = t_selector.get_targets(*active_battler.event.xy)
      $game_player.moveto(*active_battler.event.xy)
      $game_map.item_apply(user, attack_skill, ts)
    end
  end

  def selection_cancel
    moveto_nexthashstarter
    selection_placement
    $game_map.remove_actor_event(Game_Event.get($game_map.events_xy(*xy),
    /Placement/))
  end

  def selection_placement
    if @selector.include?(*xy)
      Sound.play_cursor
      $game_map.events_xy(*xy).each do |event|
        $game_map.remove_actor_event(event) if event.name =~ /Placement/
      end
      @placecommand_window.show.activate.refresh
      $game_map.mode = :fixed
    else
      Sound.play_cancel
    end
  end

  alias :stabsucm :update_call_menu
  def update_call_menu
    if $game_map.in_battle?
      @menu_calling = false
    else
      stabsucm
    end
  end

  def wait(duration)
    duration.times {|i| update_for_wait if i < duration / 2 || !show_fast? }
  end

  def pause(duration)
    duration.times do update end
  end

  def show_fast?
    Input.press?(:A) || Input.press?(:C)
  end

  alias :stabsu :update
  def update
    stabsu
    update_stabs if $game_map.in_battle?
  end

  def update_stabs
    invoke($game_map.phase)
    update_win_loss if $game_map.battle_active?
  end

  def update_win_loss
    if $game_map.victory?
      $game_map.phase = :wait_for_victory
      BattleManagerII.play_victory_me
      BattleManager.replay_bgm_and_bgs
      disable_all_windows
      $game_message
      $game_message.add(sprintf(Vocab::Victory, $game_party.name))
      $game_message.visible = true
      BattleManager.display_exp
      BattleManager.gain_gold
      BattleManager.gain_drop_items
      BattleManager.gain_exp
      wait_for_message
      BattleManagerII.battle_end(true)
    elsif $game_map.loss?
      SceneManager.goto(Scene_Gameover)
    end
  end

  def wait_for_victory
  end

  def update_for_wait
    update_basic
    @spriteset.update
  end

  def wait_for_message
    update while $game_message.visible
  end

  def wait_for_placement
    @selector.ext.each do |event|
      next if event.battler
      if event.pos?(*xy) and @placecommand_window.visible
        event.set_battler_graphic(@placecommand_window.current_ext)
      else
        event.set_graphic("", 0)
      end
    end
  end

  def wait_for_move
    event = active_battler.event
    if event.x == @target_x and event.y == @target_y
      @target_x = @target_y = -1
      pause(15)
      @spriteset.set_new_rect(:clear)
      activate_active_battler
    end
  end

  def wait_for_effects
    update_for_wait while $game_map.in_animation?
  end

  def wait_for_collapse
    return if $game_map.battle_members.any?{ |battler|
      battler.event.collapse?
    }
    next_battler
  end

end
#==============================================================================
# ■ Game_Even
#==============================================================================
class Game_Event < Game_Character
  attr_accessor :stabs_moves, :event, :collapse
  attr_reader :battler, :stored_pathing, :special_index
  attr_writer :move_speed

  alias :stabsi :initialize
  def initialize(map_id, event)
    stabsi(map_id, event)
    clear_stabs
    @stored_pathing = []
  end

  def self.get(array, regex)
    array.each do |item|
      return item if item.name =~ regex
    end
    return nil
  end

  def xy
    return @x, @y
  end

  def clear_stabs
    @stabs_moves = 0
  end

  def name
    @event.name
  end

  def reset_self_switches
    ["A","B","C","D"].each do |letter|
      key = [@map_id, @id, letter]
      $game_self_switches[key] = false
    end
  end


  def set_enemy(enemy_id, index)
    self.battler = Game_Enemy.new(index, enemy_id)
  end

  def battler=(new_battler)
    @battler = new_battler
    if @battler
      @battler.event = self
    end
  end

  def set_battler_graphic(battler)
    if battler.nil?
      set_graphic("", 0)
    elsif battler.actor?
      set_actor_graphic(battler)
    else
      set_enemy_graphic(battler)
    end
  end

  def set_actor_graphic(actor)
    set_graphic(actor.character_name, actor.character_index)
  end

  def set_enemy_graphic(enemy)
    enemy.enemy.note.scan(/<battler:?\s*(\S+)\s+(\d)>/i) do
      set_graphic($1, $2.to_i)
      return
    end
    set_graphic("", 0)
  end

  def all_enemies
    return [] unless @battler
    if $game_map.party_members.include?(@battler)
      return $game_map.enemy_members
    else
      return $game_map.party_members
    end
  end

  def all_allies
    return [] unless @battler
    if $game_map.party_members.include?(@battler)
      return $game_map.party_members
    else
      return $game_map.enemy_members
    end
  end

  def move_toward_xy(x, y)
    @target_x = x
    @target_y = y
    @stored_pathing = SceneManager.scene.selector.selected[:ext].clone
    @stored_pathing.delete_at(0)
  end

  alias :stabsu :update
  def update
    stabsu
    update_stored_movepath if $game_map.in_battle?
    update_stabs_info if $game_map.in_battle? and @battler
    update_balloon if battler
  end

  def update_balloon
    battler.states.each do |state|
      state.note.scan(/<balloon id[:\s]+(\d+)>/) do
        return @balloon_id = $1.to_i
      end
    end
    @ballon_id = 0
  end

  def update_stabs_info
    @priority_type   = 1
    @move_speed      = 4
    @through         = true
    @step_anime      = true
    @special_index   = -1
    return if !@battler.stabs_battler?
    @special_index   = get_special_index
    @step_anime      = !is_special?
    @direction_fix   = is_special?
    @character_index = get_stabs_char_i
    update_specials if is_special?
  end

  def is_special?
    @special_index >= 0
  end

  def update_event_data(page)
  end

  def update_specials
    @direction = (@special_index / 3)*2 + 2
    @pattern   = @special_index % 3
  end

  def get_stabs_char_i
    if is_special?
      7
    elsif false #Attack/Spell Animation

    else
      1
    end
  end

  def get_special_index
    @battler.states.each do |state|
      if state._s_sci != -1
        return state._s_sci
      end
    end
    return -1
  end

  def set_collapse
    @collapse = true
    SceneManager.scene.spriteset.apply_collapse(self)
  end

  def collapse?

  end

  def update_stored_movepath
    return if moving?
    return if @stored_pathing == []
    next_xy = @stored_pathing.delete_at(0)
    return if next_xy == [@x, @y]
    set_next_move(*next_xy)
  end

  def set_next_move(x, y)
    @through = true
    @stabs_moving = true
    @moving
    sx = distance_x_from(x)
    sy = distance_y_from(y)
    if sx.abs > sy.abs
      move_straight(sx > 0 ? 4 : 6)
      move_straight(sy > 0 ? 8 : 2) if !@move_succeed && sy != 0
    elsif sy != 0
      move_straight(sy > 0 ? 8 : 2)
      move_straight(sx > 0 ? 4 : 6) if !@move_succeed && sx != 0
    end
    @through = false
  end

end
#==============================================================================
# ■ Game_Player
#==============================================================================
class Game_Player < Game_Character

  alias :stabsr :refresh
  def refresh
    stabsr
    if $game_map.in_battle?
      @character_name = ""
      @followers.refresh
    end
  end

  def update
    last_real_x = @real_x
    last_real_y = @real_y
    last_moving = moving?
    move_by_input
    super
    update_scroll(last_real_x, last_real_y)
    update_vehicle
    update_nonmoving(last_moving) unless moving?
    @followers.update
  end

  alias :stabsmbi :move_by_input
  def move_by_input
    if $game_map.in_battle?
      return if !movable?
      return if $game_map.interpreter.running?
      return unless $game_map.allow_char_select?
      stabs_char_input
    else
      stabsmbi
    end
  end

  def stabs_char_input
    if Input.trigger? :UP
      return if @y == 0
      moveto @x, @y - 1
    elsif Input.trigger? :DOWN
      return if @y == $game_map.height - 1
      moveto @x, @y + 1
    elsif Input.trigger? :LEFT
      return if @x == 0
      moveto @x - 1, @y
    elsif Input.trigger? :RIGHT
      return if @x == $game_map.width - 1
      moveto @x + 1, @y
    elsif Input.trigger? :C
      SceneManager.scene.stabs_confirm
    elsif Input.trigger? :B
      SceneManager.scene.stabs_cancel
    end
  end

end

class Game_Follower < Game_Character

  alias :stabsv? :visible?
  def visible?
    stabsv? and !$game_map.in_battle?
  end
end
#==============================================================================
# ■ Spriteset_Map
#==============================================================================
class Spriteset_Map
  attr_reader :sprite_field, :viewport1, :viewport2, :viewport3

  def setup_stabs_sprites
    @sprite_field = Sprite_Rect.new(@viewport1)
    @stabs_battlerhud = Sprite_StabsBattlerHUD.new(@viewport3, 0)
    @stabs_battlerhud2 = Sprite_StabsBattlerHUD.new(@viewport3, 100)
    @sprites_collapse = []
  end

  def remove_stabs
    all_stabs_sprites.each do |sprite|
      sprite.dispose
    end
  end

  alias :stabsu :update
  def update
    stabsu
    update_stabs if $game_map.in_battle? and @sprite_field
  end

  def all_stabs_sprites
    [@sprite_field, @stabs_battlerhud, @stabs_battlerhud2] + @sprites_collapse
  end

  def update_stabs
    @sprite_field.update
    @stabs_battlerhud.battler = SceneManager.scene.active_battler
    @stabs_battlerhud2.battler = $game_map.battler_xy($game_player.x, $game_player.y)
    @stabs_battlerhud.update
    @stabs_battlerhud2.update
    Sprite_Rect.next_animation_cycle
    update_sprites_collapse
  end

  def update_sprites_collapse
    @sprites_collapse.each do |sprite|
      sprite.update
      if sprite.collapse_finished
        sprite.dispose
        @sprites_collapse.delete(sprite)
        $game_map.delete_event(sprite.character)
      end
    end
  end

  def clear_all_rect
    set_new_rect :clear
  end

  def set_new_rect(symbol)
    @sprite_field.symbol = symbol
  end

  def delete_event(event)
    @character_sprites.select! do |sprite|
      if (sprite.character == event)
        sprite.dispose
        false
      else
        true
      end
    end
  end

  def apply_collapse(event)
    @character_sprites.each do |sprite|
      if sprite.character == event
        @sprites_collapse.push(sprite)
        @character_sprites.delete(sprite)
        sprite.collapse
      end
    end
  end

  def add_event(event)
    return if @character_sprites.any? do |sprite| sprite.character == event end
    @character_sprites.push(Sprite_Character.new(@viewport1, event))
  end

end
#==============================================================================
# ■ Sprite_Rect
#==============================================================================
class Sprite_Rect < Sprite_Base
  attr_reader :mode, :symbol
  attr_accessor :selector

  @@animation_cycle = 0

  def self.next_animation_cycle
    @@animation_cycle += 1
    @@animation_cycle %= 64
  end

  def symbol=(new_symbol)
    @symbol = new_symbol
    refresh
  end

  def initialize(viewport)
    super(viewport)
    self.bitmap = Bitmap.new($game_map.width*32, $game_map.height*32)
    @symbol     = :clear
    @x          = $game_player.x
    @y          = $game_player.y
    refresh
  end

  def update
    update_selected
    update_position
    update_opacity
  end

  def refresh
    self.bitmap.clear
    add_rect($game_player.x, $game_player.y, :selected)
    return if @symbol == :clear or @selector.nil?
    @selector.xy.each do |xy|
      next if $game_player.pos?(*xy)
      add_rect(*xy, @symbol)
    end
  end

  def update_selected
    return if @x == $game_player.x and @y == $game_player.y
    @x = $game_player.x
    @y = $game_player.y
    refresh
  end

  def update_position
    self.x  = $game_map.adjust_x(0) * 32
    self.oy = $game_map.height * 32
    self.y  = $game_map.adjust_y($game_map.height) * 32
  end

  def update_opacity
    self.opacity = (32-@@animation_cycle).abs*3.0 + 96
  end

  def add_rect(x, y, symbol)
    self.bitmap.fill_rect(x*32+1, y*32+1, 30, 30, Color.new(0,0,0))
    self.bitmap.fill_rect(x*32+2, y*32+2, 28, 28, rect_color(symbol))
  end

  def rect_color(symbol)
    case symbol
    when :move
      Z3S::STABS::ColorMove
    when :physical
      Z3S::STABS::ColorPhysical
    when :magic
      Z3S::STABS::ColorMagic
    when :placement
      Z3S::STABS::ColorPlacement
    when :selected
      Z3S::STABS::ColorSelected
    else
      Color.new(255, 255, 255)
    end
  end

end
#==============================================================================
# ■ Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  attr_reader :collapse_finished

  alias :stabsuo :update_other
  def update_other
    if @collapse
      update_collapse
    else
      stabsuo
    end
  end

  def update_collapse
    self.opacity -= 6
    if self.opacity <= 128
      @collapse_finished = true
      @character.collapse = false
    end
  end

  def collapse
    @collapse = true
    self.blend_type = 1
    self.color.set(255, 128, 128, 128)
    self.opacity = 256
    Sound.play_enemy_collapse
  end

end
#==============================================================================
# ■ Window_StabsSkill
#==============================================================================
class Window_StabsSkill < Window_SkillList
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     info_viewport : Viewport for displaying information
  #--------------------------------------------------------------------------
  def initialize(help_window)
    y = help_window.height
    super(0, y, Graphics.width, Graphics.height - y)
    @help_window = help_window
  end
  #--------------------------------------------------------------------------
  # * Show Window
  #--------------------------------------------------------------------------
  def show
    select_last
    @help_window.show
    super
  end
  #--------------------------------------------------------------------------
  # * Hide Window
  #--------------------------------------------------------------------------
  def hide
    @help_window.hide
    super
  end
end
#==============================================================================
# ■ Window_PlaceCommand
#==============================================================================
class Window_PlaceCommand < Window_Command

  def initialize
    super(0,0)
  end

  def make_command_list
    super
    $game_party.members.each do |actor|
      add_command(actor.name, :actor, enable(actor), actor)
    end
    add_command("Start!", :start)
  end

  def enable(battler)
    return false if battler.dead?
    return false if $game_map.party_members.include?(battler) if battler.actor?
    return false if $game_map.party_members.size >= Z3S::STABS::MaxParty
    return true
  end

end
#==============================================================================
# ■ Window_Base
#==============================================================================
class Window_Base

  def center
    self.x = (Graphics.width-self.width)   / 2
    self.y = (Graphics.height-self.height) / 2
  end

end
#==============================================================================
# ■ Window_BattleConfirmation
#==============================================================================
class Window_BattleConfirmation < Window_Command

  def initialize
    super(0,0)
  end

  def make_command_list
    super
    add_command("Start Battle", :start)
    add_command("Back", :back)
  end

end
#==============================================================================
# ■ Window_STABSActorCommand  # temporary name
#==============================================================================
class Window_STABSActorCommand < Window_Command
  attr_accessor :battler
  def initialize(help_window)
    super(0,0)
    @help_window = help_window
  end

  def make_command_list
    super
    if @battler
      add_commands
      self.height = 2 * standard_padding + @list.size * line_height
      self.x = Graphics.width  - self.width
      self.y = Graphics.height - self.height
    end
  end

  def add_commands
    if @battler.actor?
      add_actor_commands
    else
      add_enemy_commands
    end
  end

  def add_actor_commands
    atk_skill = $data_skills[@battler.attack_skill_id]
    gud_skill = $data_skills[@battler.guard_skill_id]
    add_command("Move",   :move, @battler.event.stabs_moves < 1)
    add_command(atk_skill.name, :use_ext, @battler.usable?(atk_skill), atk_skill)
    add_skill_command
    add_command(gud_skill.name, :use_ext, @battler.usable?(gud_skill), gud_skill)
    add_command("Item",   :item)
  end

  def add_enemy_commands
    add_command("Move",   :move, @battler.event.stabs_moves < 1)
    @battler.enemy.actions.each do |action|
      skill = $data_skills[action.skill_id]
      add_command(skill.name, :use_ext, @battler.usable?(skill), skill)
    end
    add_command("Wait", :wait)
  end

  def add_skill_command
    return unless @battler.actor?
    @battler.added_skill_types.sort.each do |stype_id|
      name = $data_system.skill_types[stype_id]
      enabled = !@battler.skill_type_sealed?(stype_id)
      add_command(name, :skill, enabled, stype_id)
    end
  end

  def update
    super
    if @help_window and self.active
      case current_symbol
      when :move
        @help_window.set_text(Z3S::STABS::MoveCmd)
      when :use_ext
        @help_window.set_item(current_ext)
      when :item
        @help_window.set_text(Z3S::STABS::ItemCmd)
      when :skill
        text = sprintf(Z3S::STABS::SkillCmd, $data_system.skill_types[current_ext])
        @help_window.set_text(text)
      end
    end
  end

end
#==============================================================================
# ■ Stabs_Selector
#==============================================================================
class Stabs_Selector
  attr_reader :tags, :last_targets

  def initialize
    clear
  end

  def spriteset
    SceneManager.scene.spriteset
  end

  def clear
    @selected = []
    $game_map.width.times do |x|
      @selected[x] = Array.new($game_map.height).fill do |y|
        {:mode => :clear, :x => x, :y => y, :ext => nil}
      end
    end
    @tags     = {}
    @skill    = nil
  end

  def selected
    @selected[$game_player.x][$game_player.y]
  end

  def all_selected
    @selected.flatten.select do |hash|
      hash[:mode] != :clear
    end
  end

  def get_selected(x, y)
    @selected[x][y]
  end

  def draw_mode(x, y)
    if $game_player.pos?(x, y)
      return :selected
    else
      return @selected[x][y][:mode]
    end
  end

  def targets
    r = []
    xy.each do |xy|
      r.push($game_map.battler_xy(*xy))
    end
    return (@last_targets = r.compact)
  end

  def xy
    all_selected.collect do |hash|
      [hash[:x], hash[:y]]
    end
  end

  def ext
    all_selected.collect do |hash|
      hash[:ext]
    end
  end

  def include?(x, y)
    @selected[x][y][:mode] != :clear
  end

  def get_move_path(event)
    clear
    cascade_move(event.x, event.y, event, event.battler.stabs_move, [], 2)
  end

  def get_range(event, min, max)
    clear
    add_range(event.x, event.y, min, max)
  end

  def add_range(x, y, min, max)
    for d in min..max
      add_distance(x, y, d)
    end
  end

  def get_distance(event, d)
    clear
    add_distance(event.x, event.y, d)
  end

  def add_distance(x, y, d)
    for ox in x-d..x+d
      d2 = d - (x-ox).abs
      for oy in [y-d2, y+d2]
        @selected[ox][oy][:mode] = :targeted
      end
    end
  end

  def add_ring(x, y)
    for ox in x-1..x+1
      for oy in y-1..y+1
        next if ox == x and oy == y
        @selected[ox][oy][:mode] = :targeted
      end
    end
  end

  def get_placement
    clear
    $game_map.events.values.each do |event|
      next unless event.name =~ /Placement/i
      @selected[event.x][event.y][:mode] = :targeted
      @selected[event.x][event.y][:ext] = event
    end
  end

  def get_skill_selector(event, skill)
    skill.note.scan(/<selector\s?weapon>/i).each do
      get_weapon_selector(event)
      return
    end
    get_all_selector(event, skill.note)
    if ext.empty?
      get_default(event)
    end
  end

  def get_weapon_selector(event)
    return unless event.battler
    if event.battler.actor?
      event.battler.weapons.each do |weapon|
        get_all_selector(event, weapon.note)
      end
    end
    if ext.empty?
      get_default(event, true)
    end
  end

  def get_all_selector(event, note)
    x = event.x
    y = event.y
    note.scan(/<selector\s?distance[:\s]+(\d+)>/i) do
      add_distance(x, y, $1.to_i)
    end
    note.scan(/<selector\s?range[:\s]+(\d+)\s+(\d+)>/i) do
      add_range(x, y, $1.to_i, $2.to_i)
    end
    note.scan(/<selector\s?range[:\s]+(\d+)>/i) do
      add_range(x, y, 1, $1.to_i)
    end
    note.scan(/<selector\s?ring>/i) do
      add_ring(x, y)
    end
    note.scan(/<selector\s?splash[:\s]+(\d+)>/i) do
      @tags[:splash] = $1.to_i
    end
  end

  def get_default(event, weapon_selector = false)
    x = event.x
    y = event.y
    case @skill.scope
    when 1, 7, 9 #Single Target
      if weapon_selector
        get_distance(event, 1)
      else
        get_weapon_selector(event)
      end
    when 2, 3, 4, 5, 6 #All Targets (Includes Randoms)
      select_from(*event.all_enemies.select{|member| !member.dead?})
    when 8 #All Allies
      select_from(*event.all_allies.select{|member| !member.dead?})
    when 10 #All Dead Allies
      select_from(*event.all_allies.select{|member| member.dead?})
    end
  end

  def rect_target
    @targets.each do |target|
      @selected[target.event.x][target.event.y][:mode] = :targeted
    end
  end

  def set_skill(event, skill)
    clear
    @skill = skill
    case skill.scope
    when 11
      select_from(event.battler)
    else
      get_skill_selector(event, skill)
    end
    spriteset.set_new_rect(skill.physical? ? :physical : :magic)
  end

  def select_from(*targets)
    targets.each do |target|
      x = target.event.x
      y = target.event.y
      @selected[x][y][:mode] = :targeted
    end
  end

  def get_targets(x, y)
    t = []
    splash = @tags[:splash] || 0
    for ox in x-splash..x+splash
      d2 = splash - (ox-x).abs
      for oy in y-d2..y+d2
        t.push $game_map.battler_xy(ox, oy)
      end
    end
    return (@last_targets = t.compact)
  end

  def cascade_move(x, y, event, moves, visits, d)
    return if moves < 0
    return if visits.include?([x,y])
    return if x < 0
    return if y < 0
    return if x >= $game_map.width
    return if y >= $game_map.height
    return unless $game_map.passable?(x, y, d)
    if (e = $game_map.battler_event_xy(x, y))
      s1 = $game_map.party_members.include?(event.battler)
      s2 = $game_map.party_members.include?(e.battler)
      return if s1 != s2
    end
    v2 = visits.clone.push [x,y]
    if (!include?(x, y)) or @selected[x][y][:ext].size > v2.size
      unless $game_map.battler_event_xy(x, y)
        @selected[x][y][:mode] = :targeted
        @selected[x][y][:ext] = v2
      end
    end
    cascade_move(x, y+1, event, moves-1, v2, 8)
    cascade_move(x-1, y, event, moves-1, v2, 6)
    cascade_move(x+1, y, event, moves-1, v2, 4)
    cascade_move(x, y-1, event, moves-1, v2, 2)
  end

end
#==============================================================================
# ■ Stabs_ActionList
#==============================================================================
class Stabs_ActionList

  def initalize
    @battler = nil
    @actions = []
  end

  def self.generate(battler)
    if $game_map.in_battle?
      $game_map.actions_list.generate(battler)
    end
  end

  def generate(battler)
    @battler = battler
    @actions = create_all_actions
  end

  def create_all_actions
    all_actions
  end

  def all_actions
    if @battler.actor?
      return [$data_skills[@battler.attack_skill_id] +
      $data_skills[@battler.guard_skill_id] +
      @battler.skills]
    end
  end

end
#==============================================================================
# ■ Sprite_StabsBattlerHUD
#==============================================================================
class Sprite_StabsBattlerHUD < Sprite_Base
  attr_accessor :battler

  def initialize(viewport, x)
    super(viewport)
    self.bitmap = Bitmap.new(100, 88)
    @draw_x = x
  end

  def update
    refresh if need_refresh?
    update_position
  end

  def update_position
    self.x = @draw_x
    self.y = Graphics.height - self.height
  end

  def need_refresh?
    return true if @battler != @_battler
    return true unless @battler
    return true if @sta  != @battler.states
    return true if @hp   != @battler.hp
    return true if @mp   != @battler.mp
    return true if @tp   != @battler.tp.to_i
    return true if @mhp  != @battler.mhp
    return true if @mmp  != @battler.mmp
    return true if @mtp  != @battler.max_tp
    return true if @name != @battler.name
    return false
  end

  def refresh
    self.bitmap.clear
    self.bitmap.font.size = 16
    @_battler = @battler
    return unless @_battler
    @hp   = @battler.hp
    @mhp  = @battler.mhp
    @mp   = @battler.mp
    @mmp  = @battler.mmp
    @tp   = @battler.tp.to_i
    @mtp  = @battler.max_tp
    @name = @battler.name
    @sta  = @battler.states
    self.bitmap.draw_text(0, 0, 100, 16, @battler.name)
    self.bitmap.fill_rect(0, 26, 100, 6, Color.new(0,0,0))
    self.bitmap.fill_rect(1, 27, @battler.hp_rate * 98, 4, Color.new(255,51,51))
    self.bitmap.draw_text(0, 16, 100, 16, @mhp, 2)
    self.bitmap.draw_text(0, 16, 72, 16, "/", 2)
    self.bitmap.draw_text(0, 16, 65, 16, @hp, 2)
    if @mmp != 0
      self.bitmap.fill_rect(0, 42, 100, 6, Color.new(0,0,0))
      self.bitmap.fill_rect(1, 43, @battler.mp_rate * 98, 4, Color.new(51,153,255))
      self.bitmap.draw_text(0, 32, 100, 16, @mhp, 2)
      self.bitmap.draw_text(0, 32, 72, 16, "/", 2)
      self.bitmap.draw_text(0, 32, 65, 16, @mp, 2)
    end
    if $data_system.opt_display_tp and @mtp != 0
      self.bitmap.fill_rect(0, 58, 100, 6, Color.new(0,0,0))
      self.bitmap.fill_rect(1, 59, @battler.tp_rate * 98, 4, Color.new(102,204,51))
      self.bitmap.draw_text(0, 48, 100, 16, @mtp, 2)
      self.bitmap.draw_text(0, 48, 72, 16, "/", 2)
      self.bitmap.draw_text(0, 48, 65, 16, @tp, 2)
    end
    icons = (@battler.state_icons + @battler.buff_icons)[0, 4]
    icons.each_with_index do |n, i| draw_icon(n, 24*i, 64) end
  end

  def draw_icon(icon_index, x, y, enabled = true)
    tbitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.bitmap.blt(x, y, tbitmap, rect, enabled ? 255 : translucent_alpha)
  end

end