#==============================================================================
# Requiem ABS 9.0
#==============================================================================
# Credits: Vlad | Email: [email protected]
#------------------------------------------------------------------------------
if Requiem_Masterpiece.enabled?("Requiem Keyboard") and
   Requiem_Masterpiece.enabled?("Requiem Extended Movements", 1.5)
#------------------------------------------------------------------------------
Requiem_Masterpiece.register("Requiem ABS", 9.0, "07/28/2009")
#------------------------------------------------------------------------------
# Key used to attack
Attack_Key1 = Keys::A

# Key used to use shield and attack with 2nd weapon
Attack_Key2 = Keys::S

# Keys used to cast skills
Skill_Keys = [Keys::Num1, Keys::Num2, Keys::Num3]

# Keys used to cast items
Item_Keys = [Keys::Q, Keys::W, Keys::E]

# Auto add skills to hotkeys when learn it?
Auto_Mont_Skills = true

# Key used to change the order of the group
Group_Order_Key = Keys::Tab

# Variable used to build battle areas
# * When each enemy dies, this variable will add +1
# * When player be transfered to another map, this variable will be setted =0
Battle_Area_Variable = 0

# Use Squad battle?
USE_SBABS = true

# Show weapons icons when characters attack?
Allow_Weapons_Graphics = true

# Show shields icons when characters defend?
Allow_Shields_Graphics = true

# Allow characters attack using shield together?
Allow_attack_with_shield = false

# Allow hit count and combo damage?
Allow_Combo_Damage = true

# Recover HP and MP when character up level?
Recovery_When_LevelUp = true

# Through dropped items on map?
Through_Drop = true

# Show items names when get it?
Show_Reward = true

# Use auto Exp and Gold calculation?
# (This method will ignore the Exp and Gold value of the enemies in the Database)
Auto_EXP_Gold = true

# Divide Exp for all party member in the same proportion?
# (If not, who kills the enemy will be the only one who will get the EXP)
Divide_EXP = true

# Allow to change the group order pressing a key?
Change_Group_Order = true

# When 1st actor dies, change the group order to next actor automatically?
Next_Actor_If_Dead = true

# Index of the gold icon when it drops
Gold_Drop_Icon_Index = 147

# % of gold drop (0 ~ 100)
Gold_Drop_Rate = 75

# Time that items stay in ground (In frames)
Drop_Duration_Time = 600

# Auto Exp given by enemies (In %)
Auto_EXP_Rate = 5

# Auto Gold given by enemies (In %)
Auto_Gold_Rate = 10

# Animation showed on character when it up level
LevelUp_Animation = 40

# Divide the size of animations by:
Animations_Divide = 3

# Text showed on skill and item window when memorize some skill or item for a key
Memorized_Text = "Memorized!"

# SE played when gold drop
Gold_Drop_SE = ""

# SE played when item drop
Item_Drop_SE = ""

Fonts = {}
                 # Name | Size | Bold | Italic
Fonts["Damage"] = ["Verdana", 18, true, false]
Fonts["Hits"]   = ["Times New Roman", 26, true, true]
Fonts["Reward"] = ["Verdana", 16, false, false]

Damage_Texts = ["Miss", "Critical", "Combo", "Guard", "Level Up", "Hits", "Reflect"]

Damage_Colors = [Color.new(255,255,255), # Normal
                 Color.new(102,204,64),  # Heal
                 Color.new(255,255,64),  # Critical
                 Color.new(255,56,16),   # Combo
                 Color.new(160,152,255), # Reflect
                 Color.new(153,204,255)] # Hits

#------------------------------------------------------------------------------
class Requiem_ABS

  attr_reader :attack_key1
  attr_reader :attack_key2
  attr_reader :skill_keys
  attr_reader :item_keys
  attr_reader :group_order_key
  attr_reader :animations_divide
  attr_reader :memorized_text
  attr_reader :allow_weapons_graphics
  attr_reader :allow_shields_graphics
  attr_reader :allow_attack_with_shield
  attr_reader :allow_combo_damage
  attr_reader :levelup_animation
  attr_reader :recovery_when_levelup
  attr_reader :gold_drop_icon_index
  attr_reader :gold_drop_rate
  attr_reader :drop_duration_time
  attr_reader :show_reward
  attr_reader :drop_se
  attr_reader :auto_exp_e_gold
  attr_reader :auto_exp_rate
  attr_reader :auto_gold_rate
  attr_reader :damage_properties
  attr_reader :through_drop
  attr_reader :divide_exp
  attr_reader :change_group_order
  attr_reader :next_actor_if_dead
  attr_reader :battle_area_variable
  attr_reader :use_sbabs
  attr_reader :auto_mont_skills

  def initialize
    @attack_key1 = Attack_Key1
    @attack_key2 = Attack_Key2
    @skill_keys = Skill_Keys
    @item_keys = Item_Keys
    @group_order_key = Group_Order_Key
    @animations_divide = Animations_Divide
    @memorized_text = Memorized_Text
    @allow_weapons_graphics = Allow_Weapons_Graphics
    @allow_shields_graphics = Allow_Shields_Graphics
    @allow_attack_with_shield = Allow_attack_with_shield
    @allow_combo_damage = Allow_Combo_Damage
    @levelup_animation = LevelUp_Animation
    @recovery_when_levelup = Recovery_When_LevelUp
    @gold_drop_icon_index  = Gold_Drop_Icon_Index
    @gold_drop_rate  = Gold_Drop_Rate
    @drop_duration_time = Drop_Duration_Time
    @show_reward = Show_Reward
    @drop_se = [Gold_Drop_SE, Item_Drop_SE]
    @auto_exp_e_gold  = Auto_EXP_Gold
    @auto_exp_rate  = Auto_EXP_Rate
    @auto_gold_rate  = Auto_Gold_Rate
    @through_drop = Through_Drop
    @divide_exp = Divide_EXP
    @change_group_order = Change_Group_Order
    @next_actor_if_dead = Next_Actor_If_Dead
    @battle_area_variable = Battle_Area_Variable
    @use_sbabs = USE_SBABS
    @auto_mont_skills = Auto_Mont_Skills
    @damage_properties = {}
    @damage_properties["Damage"] = Fonts["Damage"]
    @damage_properties["Hits"] = Fonts["Hits"]
    @damage_properties["Reward"] = Fonts["Reward"]
    @damage_properties["Texts"] = Damage_Texts
    @damage_properties["Colors"] = Damage_Colors
  end

end

#------------------------------------------------------------------------------
# Module RPG
#------------------------------------------------------------------------------
module RPG

  class State

    def animation_id
      self.note.each_line { |line|
      return line.gsub('Animation = ', '').chomp.to_i if line.include?('Animation = ')
      }
      return 0
    end

    def walk_slower?
      self.note.each_line { |line| return true if line.include?("Walk Slower") }
      return false
    end

    def walk_faster?
      self.note.each_line { |line| return true if line.include?("Walk Faster") }
      return false
    end

    def dont_walk?
      self.note.each_line { |line| return true if line.include?("Don't Walk") }
      return false
    end

    def confusion?
      self.note.each_line { |line| return true if line.include?("Confusion") }
      return false
    end

    def duration
      self.note.each_line { |line|
      return line.gsub('Duration = ', '').chomp.to_i if line.include?('Duration = ')
      }
      return 300
    end

  end

  class BaseItem

    def ranged?
      self.note.each_line { |line| return true if line.include?("Ranged") }
      return false
    end

    def explosive?
      self.note.each_line { |line| return true if line.include?("Explosive") }
      return false
    end

    def bomb?
      self.note.each_line { |line| return true if line.include?("Bomb") }
      return false
    end

    def graphic
      self.note.each_line { |line|
      return line.gsub!('Graphic = ', '').chomp if line.include?('Graphic = ')
      }
      return ""
    end

    def index
      self.note.each_line { |line|
      return line.gsub('Index = ', '').chomp.to_i if line.include?('Index = ')
      }
      return 0
    end

    def move_speed
      self.note.each_line { |line|
      return line.gsub('Speed = ', '').chomp.to_i if line.include?('Speed = ')
      }
      return 4
    end

    def range
      self.note.each_line { |line|
      return line.gsub('Range = ', '').chomp.to_i if line.include?('Range = ')
      }
      return 5
    end

    def delay
      self.note.each_line { |line|
      return line.gsub('Delay = ', '').chomp.to_i if line.include?('Delay = ')
      }
      return 60
    end

    def area
      self.note.each_line { |line|
      return line.gsub('Area = ', '').chomp.to_i if line.include?('Area = ')
      }
      return 3
    end

    def shot_se
      self.note.each_line { |line|
      return line.gsub('Shot SE = ', '').chomp.to_s if line.include?('Shot SE = ')
      }
      return nil
    end

    def combo_hits
      self.note.each_line { |line|
      return line.gsub('Combo Hits = ', '').chomp.to_i if line.include?('Combo Hits = ')
      }
      return 5
    end

    def combo_rate
      self.note.each_line { |line|
      return line.gsub('Combo Rate = ', '').chomp.to_i if line.include?('Combo Rate = ')
      }
      return 75
    end

    def ammo1
      self.note.each_line { |line|
      return $data_items[line.gsub('Ammo1 = ', '').chomp.to_i] if line.include?('Ammo1 = ')
      }
      return nil
    end

    def ammo2
      self.note.each_line { |line|
      return $data_items[line.gsub('Ammo2 = ', '').chomp.to_i] if line.include?('Ammo2 = ')
      }
      return nil
    end

    def defense_rate
      self.note.each_line { |line|
      return line.gsub('Defense Rate = ', '').chomp.to_i if line.include?('Defense Rate = ')
      }
      return 50
    end

    def reflect_rate
      self.note.each_line { |line|
      return line.gsub('Reflect Rate = ', '').chomp.to_i if line.include?('Reflect Rate = ')
      }
      return 0
    end

    def path
      self.note.each_line { |line|
      return line.gsub!('Path = ', '').chomp if line.include?('Path = ')
      }
      return "Line"
    end

  end

end

#------------------------------------------------------------------------------
# Bitmap
#------------------------------------------------------------------------------
class Bitmap

  def draw_outlined_text(x, y, w, h, s, a=0, c=Font.default_color)
    font.shadow = false
    font.color = Color.new(0,0,0)
    draw_text(x-1, y-1, w, h, s, a)
    draw_text(x+1, y-1, w, h, s, a)
    draw_text(x-1, y+1, w, h, s, a)
    draw_text(x+1, y+1, w, h, s, a)
    font.color = c
    draw_text(x, y, w, h, s, a)
  end

end

#------------------------------------------------------------------------------
# Game Battler
#------------------------------------------------------------------------------
class Game_Battler

  attr_accessor :damage
  attr_accessor :critical
  attr_accessor :combo
  attr_accessor :reflect
  attr_accessor :state_turns
  attr_accessor :defending
  attr_accessor :piece

  alias requiem_abs_gbattler_initialize initialize
  alias requiem_abs_gbattler_make_obj_damage_value make_obj_damage_value

  def initialize
    @damage = 0
    requiem_abs_gbattler_initialize
  end

  def attack_effect(attacker)
    clear_action_results
    unless attack_effective?(attacker)
      @skipped = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    if rand(100) >= calc_hit(attacker)
      @missed = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    if rand(100) < calc_eva(attacker)
      @evaded = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    make_attack_damage_value(attacker)
    execute_damage(attacker)
    return if @hp_damage == 0
    apply_state_changes(attacker)
  end

  def skill_effect(user, skill)
    clear_action_results
    unless skill_effective?(user, skill)
      @skipped = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    if rand(100) >= calc_hit(user, skill)
      @missed = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    if rand(100) < calc_eva(user, skill)
      @evaded = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    make_obj_damage_value(user, skill)
    make_obj_absorb_effect(user, skill)
    execute_damage(user)
    return if skill.physical_attack and @hp_damage == 0
    apply_state_changes(skill)
  end

  def item_effect(user, item)
    clear_action_results
    unless item_effective?(user, item)
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      @skipped = true
      return
    end
    if rand(100) >= calc_hit(user, item)
      @missed = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    if rand(100) < calc_eva(user, item)
      @evaded = true
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
      return
    end
    hp_recovery = calc_hp_recovery(user, item)
    mp_recovery = calc_mp_recovery(user, item)
    make_obj_damage_value(user, item)
    @hp_damage -= hp_recovery
    @mp_damage -= mp_recovery
    make_obj_absorb_effect(user, item)
    execute_damage(user)
    item_growth_effect(user, item)
    return if item.physical_attack and @hp_damage == 0
    apply_state_changes(item)
  end

  def execute_damage(user)
    if @hp_damage == 0
      @damage = $Requiem_ABS.damage_properties["Texts"][0]
    elsif defending?(user)
      @damage = $Requiem_ABS.damage_properties["Texts"][3]
      return
    else
      if user.reflect
        user.damage = (@hp_damage/4 <= 0 ? 1 : @hp_damage/4)
      else
        @damage = @hp_damage
      end
    end
    remove_states_shock if @hp_damage > 0
    if user.reflect
      user.hp -= (@hp_damage/4 <= 0 ? 1 : @hp_damage/4)
      user.mp -= (@mp_damage/4 <= 0 ? 1 : @mp_damage/4)
    else
      self.hp -= @hp_damage
      self.mp -= @mp_damage
    end
    if @absorbed
      user.hp += @hp_damage
      user.mp += @mp_damage
    end
  end

  def make_attack_damage_value(attacker)
    damage = attacker.atk * 4 - self.def * 2
    damage = 0 if damage < 0
    damage *= elements_max_rate(attacker.element_set)
    damage /= 100
    if damage == 0
      damage = rand(2)
    elsif damage > 0
      attacker.reflect = (rand(100) < reflect_rate)
      @critical = (rand(100) < attacker.cri)
      @critical = false if prevent_critical or @reflect
      damage *= 2 if @critical
      calculate_combo(attacker)
      damage *= 3 if @combo
      damage = apply_variance(damage, 20)
      damage = apply_guard(damage)
      @hp_damage = damage
    end
  end

  def make_obj_damage_value(user, obj)
    requiem_abs_gbattler_make_obj_damage_value(user, obj)
    user.reflect = (rand(100) < reflect_rate)
  end

  def calculate_combo(attacker)
    if attacker.is_a?(Game_Actor) and $Requiem_ABS.allow_combo_damage
      if $game_player.right_attack_on and attacker.weapons[0] != nil
        hits = attacker.weapons[0].combo_hits
        rate = attacker.weapons[0].combo_rate
      elsif $game_player.left_attack_on and attacker.weapons[1] != nil
        hits = attacker.weapons[1].combo_hits
        rate = attacker.weapons[1].combo_rate
      elsif $game_player.right_attack_on and attacker.weapons[0].nil?
        hits = 5
        rate = 75
      elsif $game_player.left_attack_on and attacker.weapons[1].nil?
        hits = 5
        rate = 75
      else
        hits = rate = 0
      end
      @combo = ($game_player.hits >= hits and rand(100) <= rate)
      @combo = false if @reflect
    else
      @combo = false
    end
  end

  def attack_speed
    a = [[75, 75-(agi/10)].min, 3].max
    return a
  end

  def defending?(user)
    if self.is_a?(Game_Actor) and @defending and equips[1].is_a?(RPG::Armor) and
      rand(100) <= equips[1].defense_rate and @piece != nil and user.piece.face_to_face?(user.piece, @piece)
      return true
    elsif self.is_a?(Game_Monster) and @defending and rand(100) <= self.defense_rate and
      @piece != nil and user.piece.face_to_face?(user.piece, @piece)
      return true
    elsif self.is_a?(Game_Enemy) and @defending and rand(100) <= self.defense_rate and
      @piece != nil and user.piece.face_to_face?(user.piece, @piece)
      return true
    end
    return false
  end

  def remove_state(state_id)
    return unless state?(state_id)
    @states.delete(state_id)
    @state_turns.delete(state_id)
  end

end

#------------------------------------------------------------------------------
# Game Actor
#------------------------------------------------------------------------------
class Game_Actor < Game_Battler

  attr_accessor :skill_hotkeys
  attr_accessor :item_hotkeys

  alias requiem_abs_gactor_setup setup
  alias requiem_abs_gactor_learn_skill learn_skill
  alias requiem_abs_gactor_forget_skill forget_skill

  def setup(actor_id)
    @skill_hotkeys = {}
    @item_hotkeys  = {}
    $Requiem_ABS.skill_keys.each { |i| @skill_hotkeys[i] = 0 }
    $Requiem_ABS.item_keys.each  { |i| @item_hotkeys[i]  = 0 }
    requiem_abs_gactor_setup(actor_id)
  end

  def display_level_up(new_skills)
    $game_system.battle_end_me.play
    for ally in $game_allies.compact
      next unless id == ally.actor.id
      ally.animation_id = $Requiem_ABS.levelup_animation
    end
    if id == $game_party.members[0].id
      $game_player.animation_id = $Requiem_ABS.levelup_animation
    end
    @damage = $Requiem_ABS.damage_properties["Texts"][4]
    recover_all if $Requiem_ABS.recovery_when_levelup
  end

  def atk_animation_id2
    if two_swords_style
      return weapons[1].nil? ? 1 : weapons[1].animation_id
    else
      return 1
    end
  end

  def reflect_rate
    r = 0
    for i in armors.compact
      r += i.reflect_rate
    end
    return r
  end

  def current_exp
    return (@exp - @exp_list[@level])
  end

  def next_exp
    return (@exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0)
  end

  def learn_skill(skill_id)
    requiem_abs_gactor_learn_skill(skill_id)
    return unless $Requiem_ABS.auto_mont_skills
    a = []
    for k in @skill_hotkeys.keys.compact
      next if @skill_hotkeys[k] > 0
      a << k
    end
    @skill_hotkeys[a.min] = skill_id if a.min != nil
  end

  def forget_skill(skill_id)
    requiem_abs_gactor_forget_skill(skill_id)
    return unless $Requiem_ABS.auto_mont_skills
    for k in @skill_hotkeys.keys.compact
      @skill_hotkeys[k] = 0 if @skill_hotkeys[k] == skill_id
    end
    a = []
    for k in @skill_hotkeys.keys
      next if @skill_hotkeys[k] > 0
      a << k
    end
    b = []
    @skills.compact.each { |i| b << i }
    @skill_hotkeys[a.min] = b[rand(b.size-1)] if a.min != nil
  end

end

#------------------------------------------------------------------------------
# Game Enemy
#------------------------------------------------------------------------------
class Game_Enemy < Game_Battler

  def character_name
    enemy.note.each_line { |line|
    return line.gsub('Char Name = ', '').chomp if line.include?('Char Name = ')
    }
    return ""
  end

  def character_index
    enemy.note.each_line { |line|
    return line.gsub('Char Index = ', '').chomp.to_i if line.include?('Char Index = ')
    }
    return 0
  end

  def atk_animation_id
    enemy.note.each_line { |line|
    return line.gsub('Attack Animation = ', '').chomp.to_i if line.include?('Attack Animation = ')
    }
    return 1
  end

  def die_animation_id
    enemy.note.each_line { |line|
    return line.gsub('Die Animation = ', '').chomp.to_i if line.include?('Die Animation = ')
    }
    return 0
  end

  def die_se
    enemy.note.each_line { |line|
    return line.gsub('Die SE = ', '').chomp.to_s if line.include?('Die SE = ')
    }
    return nil
  end

  def weapon_icon
    enemy.note.each_line { |line|
    return line.gsub('Weapon Icon = ', '').chomp.to_i if line.include?('Weapon Icon = ')
    }
    return 0
  end

  def shield_icon
    enemy.note.each_line { |line|
    return line.gsub('Shield Icon = ', '').chomp.to_i if line.include?('Shield Icon = ')
    }
    return 0
  end

  def defense_rate
    enemy.note.each_line { |line|
    return line.gsub('Defense Rate = ', '').chomp.to_i if line.include?('Defense Rate = ')
    }
    return 50
  end

  def reflect_rate
    enemy.note.each_line { |line|
    return line.gsub('Reflect Rate = ', '').chomp.to_i if line.include?('Reflect Rate = ')
    }
    return 0
  end

  def move_speed
    enemy.note.each_line { |line|
    return line.gsub('Move Speed = ', '').chomp.to_i if line.include?('Move Speed = ')
    }
    return 3
  end

  def follow_range
    enemy.note.each_line { |line|
    return line.gsub('Follow Range = ', '').chomp.to_i if line.include?('Follow Range = ')
    }
    return 3
  end

  def move_route
    enemy.note.each_line { |line|
    return line.gsub('Move Route = ', '').chomp.to_i if line.include?('Move Route = ')
    }
    return 1
  end

  def respawn
    enemy.note.each_line { |line|
    return line.gsub('Respawn = ', '').chomp.to_i if line.include?('Respawn = ')
    }
    return 0
  end

end

#------------------------------------------------------------------------------
# Game Party
#------------------------------------------------------------------------------
class Game_Party < Game_Unit

  alias requiem_sbabs_gparty_setup_starting_members setup_starting_members

  def setup_starting_members
    requiem_sbabs_gparty_setup_starting_members
    for i in [email protected]
      next if @actors[i].nil?
      $game_allies[i] = Game_Ally.new(i)
    end
  end

  def add_actor(actor_id)
    if @actors.size < MAX_MEMBERS and not @actors.include?(actor_id)
      @actors.push(actor_id)
      $game_player.refresh
      id = @actors.size-1
      if @actors.size > 1 and $Requiem_ABS.use_sbabs
        $game_allies[id] = Game_Ally.new(id)
        $game_allies[id].moveto($game_player.x, $game_player.y)
        $game_allies[id].move_random
      end
    end
    $scene.refresh_sprites if $scene.is_a?(Scene_Map)
  end

  def remove_actor(actor_id)
    change_group_order if members[0].id == actor_id
    @actors.delete(actor_id)
    for ally in $game_allies.compact
      next if ally.actor.id != actor_id
      ally.destroy = true
      $game_allies.delete(ally)
    end
    $game_player.refresh
    $scene.refresh_sprites if $scene.is_a?(Scene_Map)
  end

  def change_group_order
    for ally in $game_allies.compact
      next if ally.map_id == $game_map.map_id
      return
    end
    return if members.size <= 1
    actor = @actors[0]
    @actors.delete(actor)
    @actors.compact
    if all_dead?
      @actors.insert(0, actor)
      return
    end
    @actors.push(actor)
    for a in members.compact
      if a.dead?
        ally = a
        @actors.delete(a.id)
        @actors.push(a.id)
      else
        for i in $game_allies.compact
          next if i.actor != a
          ally = i
        end
        break
      end
    end
    allies = []
    for a in $game_allies.compact
      allies.push(a)
    end
    allies.delete(ally)
    allies.push($game_player)
    allies.compact
    for i in 1...members.size
      next if members[i].nil?
      next unless $Requiem_ABS.use_sbabs
      $game_allies[i] = Game_Ally.new(i)
      $game_allies[i].refresh
      $game_allies[i].moveto(allies[i-1].x, allies[i-1].y)
      if !allies[i-1].is_a?(Game_Player)
        $game_allies[i].map_id = allies[i-1].map_id
      else
        $game_allies[i].map_id = $game_map.map_id
      end
      $game_allies[i].direction = allies[i-1].direction
    end
    $game_player.moveto(ally.x, ally.y) unless ally.nil?
    $game_player.refresh
    $scene.refresh_sprites if $scene.is_a?(Scene_Map)
  end

end

#------------------------------------------------------------------------------
# Game Map
#------------------------------------------------------------------------------
class Game_Map

  alias requiem_abs_gmap_passable passable?
  alias requiem_abs_gmap_setup_events setup_events

  def setup_events
    requiem_abs_gmap_setup_events
    $game_monsters.clear
    for area in $data_areas.values
      next unless area.map_id == @map_id
      for i in area.encounter_list
        for m in $data_troops[i].members
          $game_monsters.push(Game_Monster.new($game_monsters.size, m.enemy_id, m.id, area))
        end
      end
    end
    for i in encounter_list
      for m in $data_troops[i].members
        $game_monsters.push(Game_Monster.new($game_monsters.size, m.enemy_id, m.id, nil))
      end
    end
  end

  def range_passable?(x, y, flag = 0x01)
    return true if @passages[@map.data[x, y, 0]] == 9
    passable?(x, y, flag)
  end

  def player_passable?(x, y, flag = 0x01)
    all_passable?(x, y, flag)
  end

  def passable?(x, y, flag = 0x01)
    for ally in $game_allies.compact
      next if ally.character_name == ""
      return false if ally.x == x and ally.y == y
    end
    all_passable?(x, y, flag)
  end

  def all_passable?(x, y, flag = 0x01)
    for monster in $game_monsters.compact
      next if monster.actor.dead?
      return false if monster.x == x and monster.y == y
    end
    for drop in $game_drop.compact
      next if $Requiem_ABS.through_drop
      return false if drop.x == x and drop.y == y
    end
    for event in events_xy(x, y)
      next if event.tile_id == 0
      next if event.priority_type > 0
      next if event.through
      pass = @passages[event.tile_id]
      next if pass & 0x10 == 0x10
      return true if pass & flag == 0x00
      return false if pass & flag == flag
    end
    for i in [2, 1, 0]
      tile_id = @map.data[x, y, i]
      return false if tile_id == nil
      pass = @passages[tile_id]
      next if pass & 0x10 == 0x10
      return true if pass & flag == 0x00
      return false if pass & flag == flag
    end
    return false
  end

  def update_events
    for event in @events.values
      next unless in_range?(event) or event.trigger == 3 or event.trigger == 4
      event.update
    end
    for common_event in @common_events.values
      common_event.update
    end
  end

end

#------------------------------------------------------------------------------
# Game Character
#------------------------------------------------------------------------------
class Game_Character

  alias requiem_abs_gchar_initialize initialize
  alias requiem_abs_gchar_update update

  attr_accessor :actor
  attr_accessor :target
  attr_accessor :ani_time
  attr_accessor :state_time
  attr_accessor :weapon1_attack_time
  attr_accessor :weapon2_attack_time
  attr_accessor :assigned_skill
  attr_accessor :skill_attack_time
  attr_accessor :item_attack_time
  attr_accessor :recovery_time
  attr_accessor :right_attack_on
  attr_accessor :left_attack_on
  attr_accessor :freeze
  attr_accessor :anime_attack
  attr_accessor :lock_target
  attr_accessor :original_move_speed

  def initialize
    requiem_abs_gchar_initialize
    @weapon1_attack_time = 0
    @weapon2_attack_time = 0
    @skill_attack_time = 0
    @item_attack_time = 0
    @recovery_time = 0
    @assigned_skill = nil
    @ani_time = 0
    @anime_attack = 0
    @state_time = 0
    @original_move_speed = 0
    @actor = nil
    @target = nil
    @freeze = false
    @right_attack_on = false
    @left_attack_on = false
    @lock_target = false
  end

  def update
    requiem_abs_gchar_update
    return if $game_party.members.size <= 0
    decrease_counters
    states_effects
  end

  def decrease_counters
    @ani_time -= 1 if @ani_time > 0
    @weapon1_attack_time -= 1 if @weapon1_attack_time > 0
    @weapon2_attack_time -= 1 if @weapon2_attack_time > 0
    @skill_attack_time -= 1 if @skill_attack_time > 0
    @item_attack_time -= 1 if @item_attack_time > 0
    @recovery_time -= 1 if @recovery_time > 0
    @anime_attack -= 1 if @anime_attack > 0
    @right_attack_on = @left_attack_on = false if @anime_attack <= 0
  end

  def states_effects
    return unless is_battler?
    for state in @actor.states.compact
      if @state_time <= state.duration
        @state_time += 1
        @freeze = true if state.dont_walk?
        @move_speed = 2 if state.walk_slower?
        @move_speed = 5 if state.walk_faster?
        if is_enemy? and @actor.slip_damage?
          @actor.slip_damage_effect if Graphics.frame_count % 60 <= 0
        end
      elsif @state_time > state.duration
        @freeze = false if state.dont_walk?
        @move_speed = @original_move_speed if state.walk_slower?
        @move_speed = @original_move_speed if state.walk_faster?
        @actor.remove_state(state.id)
        @state_time = 0
      end
    end
  end

  def is_battler?
    return true if self.is_a?(Game_Player)
    return true if self.is_a?(Game_Ally)
    return true if self.is_a?(Game_Monster)
    return true if self.is_a?(Game_Event) and self.in_battle
    return false
  end

  def is_enemy?
    return true if self.is_a?(Game_Monster)
    return true if self.is_a?(Game_Event) and self.in_battle
    return false
  end

end

#------------------------------------------------------------------------------
# Game Event
#------------------------------------------------------------------------------
class Game_Event < Game_Character

  attr_reader :in_battle
  attr_reader :kill_with_weapon
  attr_reader :kill_with_skill
  attr_reader :kill_with_item
  attr_reader :respawn
  attr_reader :boss
  attr_reader :object
  attr_reader :puzzle

  alias requiem_abs_gevent_initialize initialize
  alias requiem_abs_gevent_setup setup
  alias requiem_abs_gevent_update update
  alias requiem_abs_gevent_refresh refresh

  def initialize(map_id, event)
    @enemy_id = 0
    @respawn = nil
    @in_battle = false
    @boss = false
    @auto_follow = false
    @object = false
    @puzzle = false
    requiem_abs_gevent_initialize(map_id, event)
  end

  def setup(new_page)
    requiem_abs_gevent_setup(new_page)
    self.original_move_speed = @move_speed
  end

  def update
    requiem_abs_gevent_update
    @respawn -= 1 if !@in_battle and self.actor.nil? and @respawn != nil and @respawn > 0
    if @in_battle and self.actor != nil and !self.actor.dead?
      make_attack
    elsif @in_battle and self.actor != nil and self.actor.dead?
      kill_enemy
      erasing
    elsif !@in_battle and self.actor.nil? and @respawn != nil and @respawn <= 0
      @erased = @starting = false
      refresh
    end
  end

  def refresh
    requiem_abs_gevent_refresh
    @enemy_id = check_value("Enemy")
    @self_switch_a = check_command("Die Self Switch A")
    @self_switch_b = check_command("Die Self Switch B")
    @self_switch_c = check_command("Die Self Switch C")
    @self_switch_d = check_command("Die Self Switch D")
    @switch = check_value("Die Switch")
    @variable = check_value("Die Variable")
    @kill_with_weapon = check_value("Kill With Weapon")
    @kill_with_skill = check_value("Kill With Skill")
    @kill_with_item = check_value("Kill With Item")
    @boss = check_command("Boss")
    @auto_follow = check_command("Follow")
    @object = check_command("Object")
    @puzzle = check_command("Puzzle")
    if @enemy_id > 0 and !@in_battle
      self.actor = Game_Enemy.new(0, @enemy_id)
      self.actor.recover_all
      @respawn = self.actor.respawn
      @respawn = nil if @respawn <= 0
      @follow_range = self.actor.follow_range
      self.actor.piece = self
      self.target = $game_player
      self.lock_target = false
      @in_battle = true
    elsif @enemy_id <= 0
      @in_battle = false
    end
    @opacity = 255
    @blend_type = 0
  end

  def make_attack
    return if $game_map.interpreter.running?
    return if $game_player.in_vehicle?
    for action in self.actor.enemy.actions
      next unless self.actor.conditions_met?(action)
      next unless rand(11) < action.rating
      next if self.weapon1_attack_time > 0
      case action.kind
      when 0
        case action.basic
        when 0
          attack_normal
        when 1
          self.actor.defending = true
        end
      when 1
        self.assigned_skill = $data_skills[action.skill_id]
        case self.assigned_skill.scope
        when 1...7
          if self.assigned_skill.ranged?
            if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
              skill_attack_range
            elsif action.rating == 10
              skill_attack_range
            else
              for ally in $game_allies.compact
                next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
                skill_attack_range
              end
            end
          elsif self.assigned_skill.explosive?
            if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
              skill_explode_range
            elsif action.rating == 10
              skill_explode_range
            else
              for ally in $game_allies.compact
                next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
                skill_explode_range
              end
            end
          else
            skill_attack_normal
          end
        when 7...12
          skill_recover
        end
      end
    end
  end

  def attack_normal
    for ally in $game_allies.compact
      next unless in_front?(self, ally)
      self.anime_attack = 20
      ally.animation_id = self.actor.atk_animation_id
      ally.actor.attack_effect(self.actor)
      ally.jump(0,0)
      self.weapon1_attack_time = self.actor.attack_speed
      return
    end
    return if $game_player.actor.nil?
    return unless in_front?(self, $game_player)
    self.anime_attack = 20
    $game_player.animation_id = self.actor.atk_animation_id
    $game_player.actor.attack_effect(self.actor)
    $game_player.jump(0,0)
    self.weapon1_attack_time = self.actor.attack_speed
  end

  def skill_attack_normal
    return if self.actor.mp < self.assigned_skill.mp_cost
    for ally in $game_allies.compact
      next unless in_front?(self, ally)
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      ally.animation_id = self.assigned_skill.animation_id
      ally.actor.skill_effect(self.actor, self.assigned_skill)
      ally.jump(0,0)
      self.weapon1_attack_time = self.actor.attack_speed
    end
    return if $game_player.actor.dead?
    return unless in_front?(self, $game_player)
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_player.animation_id = self.assigned_skill.animation_id
    $game_player.actor.skill_effect(self.actor, self.assigned_skill)
    $game_player.jump(0,0)
    self.weapon1_attack_time = self.actor.attack_speed
  end

  def skill_attack_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
    self.weapon1_attack_time = self.assigned_skill.delay
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
  end

  def skill_explode_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
    self.weapon1_attack_time = self.assigned_skill.delay
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
  end

  def skill_recover
    if self.actor.mp >= self.assigned_skill.mp_cost and self.actor.hp <= (self.actor.maxhp*25/100)
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      @animation_id = self.assigned_skill.animation_id
      self.actor.skill_effect(self.actor, self.assigned_skill)
      self.weapon1_attack_time = self.assigned_skill.delay
    end
    for event in $game_map.events.values
      if event.in_battle and in_range?(self, event, 3)
        if self.actor.mp >= self.assigned_skill.mp_cost and event.actor.hp <= (event.actor.maxhp*25/100)
          self.actor.mp -= self.assigned_skill.mp_cost
          $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
          event.animation_id = self.assigned_skill.animation_id
          event.actor.skill_effect(self.actor, self.assigned_skill)
          self.weapon1_attack_time = self.assigned_skill.delay
        end
      end
    end
  end

  def erasing
    return if @puzzle
    @blend_type = 2
    @opacity -= 5
  end

  def kill_enemy
    dying unless @killed
    return if @opacity > 0 and !@puzzle
    self.actor = nil
    desactive_enemy
    @killed = false
    $game_player.hits = 0
    @in_battle = false
    for ally in $game_allies.compact
      next if ally.actor.dead?
      ally.target = $game_player
      ally.lock_target = false
    end
  end

  def dying
    if $Requiem_ABS.auto_exp_e_gold and !@puzzle and !@object
      exp = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
      self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_exp_rate / 100
    else
      exp = self.actor.exp
    end
    if $Requiem_ABS.divide_exp
      x = (exp/$game_party.members.size)
      for i in $game_party.members
        i.gain_exp(x, true)
      end
    else
      self.target.actor.gain_exp(exp, true)
    end
    make_drop
    unless @puzzle
      @animation_id = self.actor.die_animation_id if self.actor.die_animation_id > 0
      if self.actor.die_se != nil
        RPG::SE.new(self.actor.die_se).play
      else
        Sound.play_enemy_collapse
      end
    end
    $game_variables[$Requiem_ABS.battle_area_variable] += 1 if $Requiem_ABS.battle_area_variable > 0
    @killed = true
  end

  def desactive_enemy
    if @self_switch_a
      key = [$game_map.map_id, self.id, "A"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @self_switch_b
      key = [$game_map.map_id, self.id, "B"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @self_switch_c
      key = [$game_map.map_id, self.id, "C"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @self_switch_d
      key = [$game_map.map_id, self.id, "D"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @switch > 0
      $game_switches[@switch] = !$game_switches[@switch]
    elsif @variable > 0
      $game_variables[@variable] += 1
    else
      erase
    end
    $game_map.need_refresh = true
  end

  def make_drop
    droped_items = []
    for i in [self.actor.drop_item1, self.actor.drop_item2]
      next if i.kind <= 0
      next if rand(i.denominator) != 0
      if i.kind == 1
        droped_items.push($data_items[i.item_id])
      elsif i.kind == 2
        droped_items.push($data_weapons[i.weapon_id])
      elsif i.kind == 3
        droped_items.push($data_armors[i.armor_id])
      end
    end
    for t in droped_items.compact
      $game_drop.push(Game_Drop.new(self, t.icon_index, t , 0))
    end
    if $Requiem_ABS.auto_exp_e_gold
      gold = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
      self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_gold_rate / 100
    else
      gold = self.actor.gold
    end
    if gold > 0 and rand(100) <= $Requiem_ABS.gold_drop_rate
      $game_drop.push(Game_Drop.new(self, $Requiem_ABS.gold_drop_icon_index, nil, gold))
    end
  end

  def update_self_movement
    return if self.actor != nil and self.actor.dead?
    return if self.freeze or (self.anime_attack/2) > 0
    return unless @stop_count > 30 * (5 - @move_frequency)
    if self.puzzle or self.object
      self.target = nil
    elsif @in_battle and in_range?(self, $game_player, @follow_range) and !self.lock_target
      self.target = $game_player
      self.lock_target = true
    end
    for ally in $game_allies.compact
      next if self.puzzle or self.object
      if @in_battle and in_range?(self, ally, @follow_range) and !ally.actor.dead? and !self.lock_target
        self.target = ally
        self.lock_target = true
      elsif self.target == ally and ally.actor.dead? and self.lock_target
        self.target = nil
        self.lock_target = false
      end
    end
    if can_follow?
      move_type_toward(self.target)
    else
      case @move_type
      when 1
        move_type_random
      when 2
        move_type_toward_player
      when 3
        move_type_custom
      end
    end
  end

  def can_follow?
    return false unless @auto_follow
    return true if @in_battle and self.target != nil and in_range?(self, self.target, @follow_range)
    return false
  end

end

#------------------------------------------------------------------------------
# Game Player
#------------------------------------------------------------------------------
class Game_Player < Game_Character

  attr_accessor :hit
  attr_accessor :hits
  attr_accessor :hit_time
  attr_accessor :assigned_item
  attr_accessor :reward

  alias requiem_abs_gplayer_initialize initialize
  alias requiem_abs_gplayer_refresh refresh
  alias requiem_abs_gplayer_update update
  alias requiem_abs_gplayer_move_by_input move_by_input
  alias requiem_abs_gplayer_perform_transfer perform_transfer

  def initialize
    requiem_abs_gplayer_initialize
    @hits = 0
    @hit_time = 0
    @assigned_item = 0
    @hit = nil
    @reward = nil
    self.original_move_speed = 4
  end

  def refresh
    self.actor = $game_party.members[0]
    self.actor.piece = self unless self.actor.nil?
    requiem_abs_gplayer_refresh
  end

  def update
    requiem_abs_gplayer_update
    return if self.actor.nil?
    return if $game_map.interpreter.running?
    return if in_vehicle?
    attack_with_weapon
    attack_with_skill
    attack_with_item
    auto_recovery
    update_hits
    if $Requiem_ABS.next_actor_if_dead
      $game_temp.next_scene = "gameover" if $game_party.all_dead?
      $game_party.change_group_order if self.actor.dead? and !$game_party.all_dead?
    elsif self.actor.dead?
      $game_temp.next_scene = "gameover"
    end
    if Input.trigger?($Requiem_ABS.group_order_key) and !Input.press?(Input::CTRL) and $Requiem_ABS.change_group_order
      $game_party.change_group_order
    end
  end

  def hit_count
    return unless $Requiem_ABS.allow_combo_damage
    @hits += 1
    @hit = "#{@hits}"
  end

  def update_hits
    if self.right_attack_on and @attack_weapon != nil
      @hits = 0 if @hit_time <= 0 or @hits >= @attack_weapon.combo_hits
    elsif self.left_attack_on and @attack_weapon_and_Shield != nil
      @hits = 0 if @hit_time <= 0 or @hits >= @attack_weapon_and_Shield.combo_hits
    elsif self.right_attack_on and @attack_weapon.nil?
      @hits = 0 if @hit_time <= 0 or @hits >= 5
    elsif self.left_attack_on and @attack_weapon_and_Shield.nil?
      @hits = 0 if @hit_time <= 0 or @hits >= 5
    end
    @hit_time -= 1 if @hit_time > 0
  end

  def attack_with_weapon
    if Input.trigger?($Requiem_ABS.attack_key1)
      return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
      return if self.weapon1_attack_time > 0
      @attack_weapon = self.actor.equips[0]
      RPG::SE.new(@attack_weapon.shot_se).play if @attack_weapon != nil and @attack_weapon.shot_se != nil
      self.anime_attack = 20
      self.right_attack_on = true
      self.left_attack_on = false
      if @attack_weapon != nil and @attack_weapon.ranged?
        range_attack_right
        self.weapon1_attack_time = @attack_weapon.delay
        @hit_time = self.weapon1_attack_time + 15
      else
        normal_attack_right
        self.weapon1_attack_time = self.actor.attack_speed
        @hit_time = self.weapon1_attack_time + 15
      end
    end
    if Input.press?($Requiem_ABS.attack_key2)
      self.actor.defending = (self.actor.equips[1].is_a?(RPG::Armor) and $Requiem_ABS.allow_shields_graphics)
    else
      self.actor.defending = false
    end
    if Input.trigger?($Requiem_ABS.attack_key2)
      return if self.weapon2_attack_time > 0
      return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
      @attack_weapon_and_Shield = (self.actor.two_swords_style ? self.actor.equips[1] : self.actor.equips[0])
      RPG::SE.new(@attack_weapon_and_Shield.shot_se).play if @attack_weapon_and_Shield != nil and @attack_weapon_and_Shield.shot_se != nil
      self.anime_attack = 20
      self.right_attack_on = false
      self.left_attack_on = true
      if @attack_weapon_and_Shield != nil and @attack_weapon_and_Shield.ranged?
        range_attack_left
        self.weapon2_attack_time = @attack_weapon_and_Shield.delay
        @hit_time = self.weapon2_attack_time + 15
      elsif self.actor.two_swords_style
        normal_attack_left
        self.weapon2_attack_time = self.actor.attack_speed
        @hit_time = self.weapon1_attack_time + 15
      end
    end
  end

  def attack_with_skill
    for button in self.actor.skill_hotkeys.keys
      if Input.trigger?(button) and self.actor.skill_hotkeys[button] != nil and self.actor.skill_hotkeys[button] != 0
        return if self.skill_attack_time > 0
        return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
        self.assigned_skill = $data_skills[self.actor.skill_hotkeys[button]]
        if self.assigned_skill.scope == 2
          skill_attack_all
        elsif self.assigned_skill.ranged?
          skill_attack_range
        elsif self.assigned_skill.explosive?
          skill_explode_range
        elsif self.assigned_skill.scope >= 7
          skill_recover
        else
          skill_attack_normal
        end
      end
    end
  end

  def attack_with_item
    for button in self.actor.item_hotkeys.keys
      if Input.trigger?(button) and self.actor.item_hotkeys[button] != nil and self.actor.item_hotkeys[button] != 0
        return if self.item_attack_time > 0
        return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
        @assigned_item = $data_items[self.actor.item_hotkeys[button]]
        if @assigned_item.ranged?
          item_attack_range
        elsif @assigned_item.explosive?
          item_attack_explode
        elsif  @assigned_item.bomb?
          item_attack_bomb
        else
          case @assigned_item.scope
          when 1
            item_normal_attack
          when 2
            item_attack_all
          when 3...7
            item_normal_attack
          when 7...12
            item_recover
          end
        end
      end
    end
  end

  def normal_attack_right
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      monster.animation_id = self.actor.atk_animation_id
      hit_count
      monster.actor.attack_effect(self.actor)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self, event)
      next if event.actor.dead? or event.object
      event.animation_id = self.actor.atk_animation_id
      hit_count
      return if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon.id or
      event.kill_with_skill > 0 or event.kill_with_item > 0
      event.actor.attack_effect(self.actor)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def range_attack_right
    return if @attack_weapon.ammo1 != nil and !$game_party.has_item?(@attack_weapon.ammo1)
    $game_party.consume_item(@attack_weapon.ammo1) if @attack_weapon.ammo1 != nil
    $game_range.push(Game_Range.new(self, @attack_weapon.graphic, @attack_weapon.index, @attack_weapon.move_speed, @attack_weapon.range, 1))
  end

  def normal_attack_left
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      monster.animation_id = self.actor.atk_animation_id2
      hit_count
      monster.actor.attack_effect(self.actor)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self,event)
      next if event.actor.dead? or event.object
      event.animation_id = self.actor.atk_animation_id2
      hit_count
      return if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon_and_Shield.id or
      event.kill_with_skill > 0 or event.kill_with_item > 0
      event.actor.attack_effect(self.actor)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def range_attack_left
    return if @attack_weapon_and_Shield.ammo2 != nil and !$game_party.has_item?(@attack_weapon_and_Shield.ammo2)
    $game_party.consume_item(@attack_weapon_and_Shield.ammo2) if @attack_weapon_and_Shield.ammo2 != nil
    $game_range.push(Game_Range.new(self, @attack_weapon_and_Shield.graphic, @attack_weapon_and_Shield.index, @attack_weapon_and_Shield.move_speed, @attack_weapon_and_Shield.range, 2))
  end

  def skill_attack_normal
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      next unless self.actor.mp >= self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      monster.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      monster.actor.skill_effect(self.actor, self.assigned_skill)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self,event)
      next if event.actor.dead? or event.object
      next unless self.actor.mp >= self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      event.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
      event.actor.skill_effect(self.actor, self.assigned_skill)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def skill_attack_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
    self.skill_attack_time = self.assigned_skill.delay
  end

  def skill_attack_all
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    for monster in $game_monsters.compact
      next if monster.actor.dead?
      monster.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      monster.actor.skill_effect(self.actor, self.assigned_skill)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next if event.actor.dead? or event.object
      event.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
      event.actor.skill_effect(self.actor, self.assigned_skill)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def skill_explode_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
    self.skill_attack_time = self.assigned_skill.delay
  end

  def skill_recover
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    self.actor.skill_effect(self.actor, self.assigned_skill)
    @animation_id = self.assigned_skill.animation_id
    self.skill_attack_time = 60
  end

  def item_normal_attack
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      next unless $game_party.has_item?(@assigned_item)
      $game_party.consume_item(@assigned_item)
      $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
      monster.animation_id = @assigned_item.animation_id
      self.item_attack_time = @assigned_item.delay
      monster.actor.item_effect(self.actor, @assigned_item)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self,event)
      next if event.actor.dead? or event.object
      next unless $game_party.has_item?(@assigned_item)
      $game_party.consume_item(@assigned_item)
      $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
      event.animation_id = @assigned_item.animation_id
      self.item_attack_time = @assigned_item.delay
      return if event.kill_with_weapon > 0 or event.kill_with_skill > 0 or
      event.kill_with_item > 0 and event.kill_with_item != self.assigned_item.id
      event.actor.item_effect(self.actor, @assigned_item)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def item_attack_range
    return unless $game_party.has_item?(@assigned_item)
    $game_party.consume_item(@assigned_item)
    $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
    $game_range.push(Game_Range.new(self, @assigned_item.graphic, @assigned_item.index, @assigned_item.move_speed, @assigned_item.range, 5))
    RPG::SE.new(@assigned_item.shot_se).play if @assigned_item.shot_se != nil
    self.item_attack_time = @assigned_item.delay
  end

  def item_attack_explode
    return unless $game_party.has_item?(@assigned_item)
    $game_party.consume_item(@assigned_item)
    $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
    $game_range.push(Game_Range.new(self, @assigned_item.graphic, @assigned_item.index, @assigned_item.move_speed, @assigned_item.range, 6))
    RPG::SE.new(@assigned_item.shot_se).play if @assigned_item.shot_se != nil
    self.item_attack_time = @assigned_item.delay
  end

  def item_recover
    return unless $game_party.has_item?(@assigned_item)
    $game_party.consume_item(@assigned_item)
    $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
    @animation_id = @assigned_item.animation_id
    self.actor.item_effect(self.actor, @assigned_item)
    self.item_attack_time = @assigned_item.delay
  end

  def item_attack_all
    next unless $game_party.has_item?(@assigned_item)
    $game_party.consume_item(@assigned_item)
    $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
      monster.animation_id = @assigned_item.animation_id
      self.item_attack_time = @assigned_item.delay
      monster.actor.item_effect(self.actor, @assigned_item)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next if event.actor.dead? or event.object
      event.animation_id = @assigned_item.animation_id
      self.item_attack_time = @assigned_item.delay
      return if event.kill_with_weapon > 0 or event.kill_with_skill > 0 or
      event.kill_with_item > 0 and event.kill_with_item != self.assigned_item.id
      event.actor.item_effect(self.actor, @assigned_item)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def item_attack_bomb
    return unless $game_party.has_item?(@assigned_item)
    $game_party.consume_item(@assigned_item)
    $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
    $game_bomb.push(Game_Bomb.new(self, @assigned_item))
    self.item_attack_time = 60
  end

  def auto_recovery
    return unless self.actor.auto_hp_recover and self.recovery_time <= 0
    self.actor.hp += (self.actor.maxhp*10/100)
    self.recovery_time = 1800
  end

  def perform_transfer
    requiem_abs_gplayer_perform_transfer
    for range in $game_range.compact
      range.destroy = true
    end
    for drop in $game_drop.compact
      drop.destroy = true
    end
    for bomb in $game_bomb.compact
      bomb.destroy = true
    end
    for ally in $game_allies.compact
      ally.perform_transfer(@new_map_id, @new_x, @new_y, @new_direction) unless ally.actor.dead?
      ally.refresh
    end
    $game_variables[$Requiem_ABS.battle_area_variable] = 0 if $Requiem_ABS.battle_area_variable > 0
  end

  def map_passable?(x, y)
    case @vehicle_type
    when 0
      return $game_map.boat_passable?(x, y)
    when 1
      return $game_map.ship_passable?(x, y)
    when 2
      return true
    else
      return $game_map.player_passable?(x, y)
    end
  end

  def move_by_input
    return if self.freeze or (self.anime_attack/2) > 0
    if self.actor != nil
      for state in self.actor.states.compact
        next unless state.confusion?
        return unless movable?
        return if $game_map.interpreter.running?
        case Input.dir4
        when 2,4,6,8
          move_random
        end
        return
      end
    end
    requiem_abs_gplayer_move_by_input
  end

end

#------------------------------------------------------------------------------
# Game Ally
#------------------------------------------------------------------------------
class Game_Ally < Game_Character

  attr_reader :id
  attr_accessor :map_id
  attr_accessor :draw
  attr_accessor :destroy
  attr_accessor :command

  def initialize(id)
    super()
    @id = id
    @map_id = $game_map.map_id
    @command = 0
    @draw = false
    @destroy = false
    self.target = $game_player
    self.original_move_speed = 4
    refresh
  end

  def update
    super
    return if @destroy
    if self.actor.dead? and !@dead
      refresh
      @dead = true
    elsif !self.actor.dead? and @dead
      refresh
      @dead = false
    end
    if $game_player.in_vehicle? and !@in_vehicle and !self.actor.defending
      refresh
      @in_vehicle = true
    elsif !$game_player.in_vehicle? and @in_vehicle
      refresh
      moveto($game_player.x, $game_player.y) unless self.actor.dead?
      @in_vehicle = false
    end
    return if self.actor.nil? or self.actor.dead? or $game_player.in_vehicle?
    self.actor.defending = (@command == 2 ? true : false)
    make_action
    auto_recovery
    update_movement
  end

  def refresh
    self.actor = $game_party.members[@id]
    self.actor.piece = self
    if $game_player.in_vehicle? and !self.actor.dead? and !self.actor.defending
      @character_name = ""
    elsif self.actor.dead?
      if File.exists?("Graphics/Characters/$#{self.actor.name}_dead.png") and @map_id == $game_map.map_id
        @character_name = "$#{self.actor.name}_dead"
        @character_index = 0
      else
        @character_name = ""
      end
    elsif @map_id != $game_map.map_id
      @character_name = ""
    else
      @character_name = self.actor.character_name
      @character_index = self.actor.character_index
    end
  end

  def make_action
    return if $game_map.interpreter.running?
    return if self.actor.dead?
    case @command
    when 0
      if self.actor.weapons[0] != nil and self.actor.weapons[0].ranged? and self.weapon1_attack_time <= 0
        weapon_range_attack
        self.weapon1_attack_time = self.actor.weapons[0].delay
      else
        if self.actor.two_swords_style
          if self.weapon1_attack_time <= 0 and rand(100) <= 50
            normal_attack_right
            self.weapon1_attack_time = self.actor.attack_speed
          elsif self.weapon1_attack_time <= 0 and rand(100) > 50
            normal_attack_left
            self.weapon1_attack_time = self.actor.attack_speed
          end
        elsif self.weapon1_attack_time <= 0
          normal_attack_right
          self.weapon1_attack_time = self.actor.attack_speed
        end
      end
    when 1
      return if self.skill_attack_time > 0 or self.actor.skills == []
      self.assigned_skill = self.actor.skills[rand(self.actor.skills.size)]
      case self.assigned_skill.scope
      when 1
        if self.assigned_skill.ranged?
          skill_attack_range
        elsif self.assigned_skill.explosive?
          skill_explode_range
        else
          skill_attack_normal
        end
      when 2
        skill_attack_all
      when 3...7
        if self.assigned_skill.ranged?
          skill_attack_range
        elsif self.assigned_skill.explosive?
          skill_explode_range
        else
          skill_attack_normal
        end
      end
    when 3
      for skill in self.actor.skills
        self.assigned_skill = skill
        case self.assigned_skill.scope
        when 7...12
          skill_recover
        end
      end
    end
  end

  def normal_attack_right
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      self.anime_attack = 20
      self.right_attack_on = true
      self.left_attack_on = false
      monster.animation_id = self.actor.atk_animation_id
      monster.actor.attack_effect(self.actor)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self, event)
      next if event.actor.dead? or event.object
      self.anime_attack = 20
      self.right_attack_on = true
      self.left_attack_on = false
      event.animation_id = self.actor.atk_animation_id
      next if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon.id or
      event.kill_with_skill > 0 or event.kill_with_item > 0
      event.actor.attack_effect(self.actor)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def weapon_range_attack
    for monster in $game_monsters
      next unless in_direction?(self, monster) and in_range?(self, monster, self.actor.weapons[0].range)
      next if monster.actor.dead?
      self.anime_attack = 20
      select = rand(100)
      self.right_attack_on = select >= 50
      self.left_attack_on = select < 50
      if $game_party.has_item?(select >= 50 ? self.actor.weapons[0].ammo1 : self.actor.weapons[0].ammo2)
        $game_party.consume_item(select >= 50 ? self.actor.weapons[0].ammo1 : self.actor.weapons[0].ammo2)
        $game_range.push(Game_Range.new(self, self.actor.weapons[0].graphic, self.actor.weapons[0].index, self.actor.weapons[0].move_speed, self.actor.weapons[0].range, (select >= 50 ? 1 : 2)))
      end
      self.weapon1_attack_time = self.actor.equips[0].delay
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_direction?(self, event) and in_range?(self, event, self.actor.weapons[0].range)
      next if event.actor.dead? or event.object
      self.anime_attack = 20
      select = rand(100)
      self.right_attack_on = select >= 50
      self.left_attack_on = select < 50
      if $game_party.has_item?(select >= 50 ? self.actor.weapons[0].ammo1 : self.actor.weapons[0].ammo2)
        $game_party.consume_item(select >= 50 ? self.actor.weapons[0].ammo1 : self.actor.weapons[0].ammo2)
        $game_range.push(Game_Range.new(self, self.actor.weapons[0].graphic, self.actor.weapons[0].index, self.actor.weapons[0].move_speed, self.actor.weapons[0].range, (select >= 50 ? 1 : 2)))
      end
      self.weapon1_attack_time = self.actor.equips[0].delay
    end
  end

  def range_attack_right
    return if @attack_weapon.ammo1 != nil and !$game_party.has_item?(@attack_weapon.ammo1)
    $game_party.consume_item(@attack_weapon.ammo1) if @attack_weapon.ammo1 != nil
    $game_range.push(Game_Range.new(self, @attack_weapon.graphic, @attack_weapon.index, @attack_weapon.move_speed, @attack_weapon.range, 1))
  end

  def normal_attack_left
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      self.anime_attack = 20
      self.right_attack_on = false
      self.left_attack_on = true
      monster.animation_id = self.actor.atk_animation_id2
      monster.actor.attack_effect(self.actor)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self,event)
      next if event.actor.dead? or event.object
      self.anime_attack = 20
      self.right_attack_on = false
      self.left_attack_on = true
      event.animation_id = self.actor.atk_animation_id2
      next if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon_and_Shield.id or
      event.kill_with_skill > 0 or event.kill_with_item > 0
      event.actor.attack_effect(self.actor)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def range_attack_left
    return if @attack_weapon_and_Shield.ammo2 != nil and !$game_party.has_item?(@attack_weapon_and_Shield.ammo2)
    $game_party.consume_item(@attack_weapon_and_Shield.ammo2) if @attack_weapon_and_Shield.ammo2 != nil
    $game_range.push(Game_Range.new(self, @attack_weapon_and_Shield.graphic, @attack_weapon_and_Shield.index, @attack_weapon_and_Shield.move_speed, @attack_weapon_and_Shield.range, 2))
  end

  def skill_attack_normal
    for monster in $game_monsters.compact
      next unless in_front?(self, monster)
      next if monster.actor.dead?
      next if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      monster.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      monster.actor.skill_effect(self.actor, self.assigned_skill)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_front?(self,event)
      next if event.actor.dead? or event.object
      next if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      event.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
      event.actor.skill_effect(self.actor, self.assigned_skill)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def skill_attack_range
    for monster in $game_monsters.compact
      next if monster.actor.dead?
      next unless in_direction?(self, monster) and in_range?(self, monster, self.assigned_skill.range)
      next if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
      RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
      self.skill_attack_time = self.assigned_skill.delay
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_direction?(self, event) and in_range?(self, event, self.assigned_skill.range)
      next self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
      RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
      self.skill_attack_time = self.assigned_skill.delay
    end
  end

  def skill_attack_all
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    for monster in $game_mosnters.compact
      next if monster.actor.dead?
      monster.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      monster.actor.skill_effect(self.actor, self.assigned_skill)
      monster.jump(0,0)
      monster.target = self
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next if event.actor.dead? or event.object
      event.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
      next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
      event.actor.skill_effect(self.actor, self.assigned_skill)
      event.jump(0,0) unless event.puzzle
      event.target = self
    end
  end

  def skill_explode_range
    for monster in $game_monsters.compact
      next if monster.actor.dead?
      return unless in_direction?(self, monster) and in_range?(self, monster, self.assigned_skill.range)
      return if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
      RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
      self.skill_attack_time = self.assigned_skill.delay
    end
    for event in $game_map.events.values
      next unless event.in_battle
      return unless in_direction?(self, event) and in_range?(self, event, self.assigned_skill.range)
      return if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
      RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
      self.skill_attack_time = self.assigned_skill.delay
    end
  end

  def skill_recover
    for person in $game_party.members
      next unless person.hp <= (person.maxhp/4)
      next if self.actor.mp < self.assigned_skill.mp_cost
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      person.skill_effect(person, self.assigned_skill)
      person.piece.animation_id = self.assigned_skill.animation_id
      self.skill_attack_time = self.assigned_skill.delay
    end
  end

  def auto_recovery
    return unless self.actor.auto_hp_recover and self.recovery_time <= 0
    self.actor.hp += (self.actor.maxhp*10/100)
    self.recovery_time = 1800
  end

  def update_movement
    return if $game_map.interpreter.running?
    return if moving?
    return if self.freeze or (self.anime_attack/2) > 0
    if $game_player.dash? and self.target == $game_player
      @move_speed = 5
    else
      @move_speed = self.original_move_speed
    end
    if @target.nil? or @command >= 2
      self.target = $game_player
    else
      for monster in $game_monsters.compact
        next if monster.actor.dead?
        if in_range?(self, monster, 3) and !self.lock_target
          self.target = monster
          self.lock_target = true
        elsif !self.lock_target
          self.target = $game_player
        end
      end
      for event in $game_map.events.values
        if event.in_battle and in_range?(self, event, 3) and !self.lock_target
          next if event.object or event.puzzle
          self.target = event
          self.lock_target = true
        elsif !self.lock_target
          self.target = $game_player
        end
      end
    end
    move_toward(self.target)
  end

  def perform_transfer(map_id, x, y, dir)
    @map_id = map_id
    set_direction(dir)
    moveto(x, y)
    move_random
    self.target = $game_player
    self.lock_target = false
  end

  def screen_z
    return $game_player.screen_z-1
  end

  def in_vehicle?
    return $game_player.in_vehicle?
  end

end

#------------------------------------------------------------------------------
# Game Monster
#------------------------------------------------------------------------------
class Game_Monster < Game_Character

  attr_reader :respawn
  attr_accessor :draw
  attr_accessor :destroy

  def initialize(id, enemy_id, troop_id, area)
    super()
    @id = id
    @enemy_id = enemy_id
    @troop_id = troop_id
    @area = area
    setup_monster
    loop do
      set_start_position
      break if $game_map.passable?(@x_pos, @y_pos) and !empty_area?
    end
    moveto(@x_pos, @y_pos)
    @move_type = self.actor.move_route
    @move_speed = self.actor.move_speed
    @draw = false
    refresh
  end

  def setup_monster
    self.actor = Game_Enemy.new(0, @enemy_id)
    self.actor.piece = self
    @respawn = self.actor.respawn
    self.actor.recover_all
    @draw = false
    @destroy = false
    @killed = false
    @opacity = 255
    @blend_type = 0
    refresh
  end

  def set_start_position
    if @area != nil
      x = []
      for i in (@area.rect.x)...(@[email protected])
        x << i
      end
      y = []
      for i in (@area.rect.y)...(@[email protected])
        y << i
      end
      @x_pos = x[rand(x.size)]
      @y_pos = y[rand(y.size)]
    else
      @x_pos = rand($game_map.width)
      @y_pos = rand($game_map.height)
    end
  end

  def empty_area?
    x = []; y = []
    for area in $data_areas.values
      next unless area.map_id == $game_map.map_id
      next unless area.name == "EMPTY"
      x = (area.rect.x)...(area.rect.x+area.rect.width)
      y = (area.rect.y)...(area.rect.y+area.rect.height)
    end
    return true if x.include?(@x_pos) and y.include?(@y_pos)
    return false
  end

  def refresh
    @character_name = self.actor.character_name
    @character_index = self.actor.character_index
  end

  def update
    super
    if !self.actor.dead?
      update_attack
    else
      update_dying
    end
  end

  def update_attack
    return if $game_map.interpreter.running?
    return if $game_player.in_vehicle?
    for action in self.actor.enemy.actions
      next unless self.actor.conditions_met?(action)
      next unless rand(11) < action.rating
      next if self.weapon1_attack_time > 0
      case action.kind
      when 0
        case action.basic
        when 0
          attack_normal
        when 1
          self.actor.defending = true
        end
      when 1
        self.assigned_skill = $data_skills[action.skill_id]
        case self.assigned_skill.scope
        when 1...7
          if self.assigned_skill.ranged?
            if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
              skill_attack_range
            elsif action.rating == 10
              skill_attack_range
            else
              for ally in $game_allies.compact
                next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
                skill_attack_range
              end
            end
           elsif self.assigned_skill.explosive?
            if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
              skill_explode_range
            elsif action.rating == 10
              skill_explode_range
            else
              for ally in $game_allies.compact
                next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
                skill_explode_range
              end
            end
          else
            skill_attack_normal
          end
        when 7...12
          skill_recover
        end
      end
    end
  end

  def attack_normal
    for ally in $game_allies.compact
      next unless in_front?(self, ally)
      self.anime_attack = 20
      ally.animation_id = self.actor.atk_animation_id
      ally.actor.attack_effect(self.actor)
      ally.jump(0,0)
      self.weapon1_attack_time = self.actor.attack_speed
      return
    end
    return if $game_player.actor.nil?
    return unless in_front?(self, $game_player)
    self.anime_attack = 20
    $game_player.animation_id = self.actor.atk_animation_id
    $game_player.actor.attack_effect(self.actor)
    $game_player.jump(0,0)
    self.weapon1_attack_time = self.actor.attack_speed
  end

  def skill_attack_normal
    return if self.actor.mp < self.assigned_skill.mp_cost
    for ally in $game_allies.compact
      next unless in_front?(self, ally)
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      ally.animation_id = self.assigned_skill.animation_id
      ally.actor.skill_effect(self.actor, self.assigned_skill)
      ally.jump(0,0)
      self.weapon1_attack_time = self.actor.attack_speed
    end
    return if $game_player.actor.nil?
    return unless in_front?(self, $game_player)
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_player.animation_id = self.assigned_skill.animation_id
    $game_player.actor.skill_effect(self.actor, self.assigned_skill)
    $game_player.jump(0,0)
    self.weapon1_attack_time = self.actor.attack_speed
  end

  def skill_attack_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
    self.weapon1_attack_time = self.assigned_skill.delay
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
  end

  def skill_explode_range
    return unless self.actor.mp >= self.assigned_skill.mp_cost
    self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
    $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
    $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
    self.weapon1_attack_time = self.assigned_skill.delay
    RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
  end

  def skill_recover
    if self.actor.mp >= self.assigned_skill.mp_cost and self.actor.hp <= (self.actor.maxhp*25/100)
      self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
      $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
      @animation_id = self.assigned_skill.animation_id
      self.actor.skill_effect(self.actor, self.assigned_skill)
      self.weapon1_attack_time = self.actor.attack_speed
    end
    for event in $game_map.events.values
      if event.in_battle and in_range?(self, event, 3)
        if self.actor.mp >= self.assigned_skill.mp_cost and event.actor.hp <= (event.actor.maxhp*25/100)
          self.actor.mp -= self.assigned_skill.mp_cost
          $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
          event.animation_id = self.assigned_skill.animation_id
          event.actor.skill_effect(self.actor, self.assigned_skill)
          self.weapon1_attack_time = self.actor.attack_speed
        end
      end
    end
  end

  def update_dying
    @blend_type = 2
    @opacity -= 5
    get_rewards unless @killed
    if @opacity <= 0 and !@destroy
      $game_player.hits = 0
      for ally in $game_allies.compact
        next if ally.actor.dead?
        ally.target = $game_player
        ally.lock_target = false
      end
      @destroy = true
    end
    if @destroy and @respawn > 0
      @respawn -= 1
      setup_monster if @respawn <= 0
    end
  end

  def get_rewards
    if $Requiem_ABS.auto_exp_e_gold
      exp = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
      self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_exp_rate / 100
    else
      exp = self.actor.exp
    end
    if $Requiem_ABS.divide_exp
      x = (exp/$game_party.members.size)
      for i in $game_party.members
        i.gain_exp(x, true)
      end
    else
      self.target.actor.gain_exp(exp, true)
    end
    droped_items = []
    for i in [self.actor.drop_item1, self.actor.drop_item2]
      next if i.kind <= 0
      next if rand(i.denominator) != 0
      if i.kind == 1
        droped_items.push($data_items[i.item_id])
      elsif i.kind == 2
        droped_items.push($data_weapons[i.weapon_id])
      elsif i.kind == 3
        droped_items.push($data_armors[i.armor_id])
      end
    end
    for t in droped_items.compact
      $game_drop.push(Game_Drop.new(self, t.icon_index, t , 0))
    end
    if $Requiem_ABS.auto_exp_e_gold
      gold = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
      self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_gold_rate / 100
    else
      gold = self.actor.gold
    end
    if gold > 0 and rand(100) <= $Requiem_ABS.gold_drop_rate
      $game_drop.push(Game_Drop.new(self, $Requiem_ABS.gold_drop_icon_index, nil, gold))
    end
    @animation_id = self.actor.die_animation_id if self.actor.die_animation_id > 0
    if self.actor.die_se != nil
      RPG::SE.new(self.actor.die_se).play
    else
      Sound.play_enemy_collapse
    end
    $game_variables[$Requiem_ABS.battle_area_variable] += 1 if $Requiem_ABS.battle_area_variable > 0
    @killed = true
  end

  def update_self_movement
    return if moving?
    return if self.actor.dead?
    return if self.freeze or (self.anime_attack/2) > 0
    return unless @stop_count > 30 * (5 - @move_frequency)
    if in_range?(self, $game_player, self.actor.follow_range) and !self.lock_target
      self.target = $game_player
      self.lock_target = true
    end
    for ally in $game_allies.compact
      if in_range?(self, ally, self.actor.follow_range) and !ally.actor.dead? and !self.lock_target
        self.target = ally
        self.lock_target = true
      elsif self.target == ally and ally.actor.dead? and self.lock_target
        self.target = nil
        self.lock_target = false
      end
    end
    if self.target != nil and in_range?(self, self.target, self.actor.follow_range)
      move_type_toward(self.target)
    else
      case @move_type
      when 1
        move_type_random
      when 2
        move_type_toward_player
      when 3
        move_type_custom
      end
    end
  end

end

#------------------------------------------------------------------------------
# Game Range
#------------------------------------------------------------------------------
class Game_Range < Game_Character

  attr_accessor :draw
  attr_accessor :destroy

  def initialize(parent, chara_name="", chara_index=0, speed=4, range=5, type=3)
    super()
    @parent = parent
    @character_name = chara_name
    @character_index = chara_index
    @move_speed = speed
    @range = range
    @type = type
    @step = 0
    @destroy = false
    @draw = false
    @moving = false
    @direction = @parent.direction
    moveto(@parent.x, @parent.y)
    case @type
    when 1
      @item = @parent.actor.equips[0]
    when 2
      if @parent.actor.two_hands_legal?
        @item = @parent.actor.equips[0]
      else
        @item = @parent.actor.equips[1]
      end
    when 3...5
      @item = @parent.assigned_skill
    when 5...7
      @item = @parent.assigned_item
    end
  end

  def update
    super
    return if @destroy
    @destroy = (@step > @range)
    return unless stopping?
    case @item.path
    when "Line"
      unless @moving
        @move_route = RPG::MoveRoute.new
        for i in 0...@range
          @move_route.list.insert(0, RPG::MoveCommand.new(12))
        end
        @moving = true
      end
    when "Boom"
      unless @moving
        @move_route = RPG::MoveRoute.new
        @move_route.list = [
        RPG::MoveCommand.new(12),
        RPG::MoveCommand.new(12),
        RPG::MoveCommand.new(12),
        RPG::MoveCommand.new(12),
        RPG::MoveCommand.new(12),
        RPG::MoveCommand.new(13),
        RPG::MoveCommand.new(13),
        RPG::MoveCommand.new(13),
        RPG::MoveCommand.new(13),
        RPG::MoveCommand.new(13),
        RPG::MoveCommand.new()]
        @range = @move_route.list.size-1
        @moving = true
      end
    when "Circle"
      unless @moving
        $game_player.anime_attack = 70
        @move_route = RPG::MoveRoute.new
        @move_route.list = [
        RPG::MoveCommand.new(37),
        RPG::MoveCommand.new(4),
        RPG::MoveCommand.new(2),
        RPG::MoveCommand.new(1),
        RPG::MoveCommand.new(1),
        RPG::MoveCommand.new(3),
        RPG::MoveCommand.new(3),
        RPG::MoveCommand.new(4),
        RPG::MoveCommand.new(4),
        RPG::MoveCommand.new(2),
        RPG::MoveCommand.new()]
        @range = @move_route.list.size-1
        @moving = true
      end
    when "Jump"
       unless @moving
        @move_route = RPG::MoveRoute.new
        case @parent.direction
        when 2; dir = 0, 3
        when 4; dir = -3, 0
        when 6; dir = 3, 0
        when 8; dir = 0, -3
        end
        @move_route.list = [
        RPG::MoveCommand.new(14, [dir[0], dir[1]]),
        RPG::MoveCommand.new()]
        @moving = true
      end
    when "Random"
      unless @moving
        @move_route = RPG::MoveRoute.new
        for i in 0...@range
          @move_route.list.insert(0, RPG::MoveCommand.new(9))
        end
        @moving = true
      end
    end
    @move_route.skippable = true
    move_type_custom
    x = (@direction == 4 ? -1 : @direction == 6 ? 1 : 0)
    y = (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    check_event_trigger_touch(@x+x, @y+y) unless jumping?
    @step += 1
  end

  def check_event_trigger_touch(x, y)
    return if @destroy
    if @parent.is_a?(Game_Event) or @parent.is_a?(Game_Monster)
      case @type
      when 3
         for ally in $game_allies.compact
           hurt_hero_skill(ally) if ally.pos?(x, y)
         end
         hurt_hero_skill($game_player) if $game_player.pos?(x, y)
      when 4
        for ally in $game_allies.compact
          hurt_hero_skill_explode if ally.pos?(x, y)
        end
        hurt_hero_skill_explode if $game_player.pos?(x, y)
      end
      return
    end
    for monster in $game_monsters.compact
      next unless monster.pos?(x, y)
      case @type
      when 1
        hurt_monster_weapon_right(monster)
      when 2
        hurt_monster_weapon_left(monster)
      when 3
        hurt_monster_skill(monster)
      when 4
        hurt_enemy_skill_explode
      when 5
        hurt_monster_item(monster)
      when 6
        hurt_enemy_item_explode
      end
    end
    for event in $game_map.events.values
      next unless event.in_battle and event.pos?(x, y)
      case @type
      when 1
        hurt_enemy_weapon_right(event)
      when 2
        hurt_enemy_weapon_left(event)
      when 3
        hurt_enemy_skill(event)
      when 4
        hurt_enemy_skill_explode
      when 5
        hurt_enemy_item(event)
      when 6
        hurt_enemy_item_explode
      end
    end
  end

  def hurt_hero_skill(hero)
    return if self.target == hero
    return if hero.actor.dead?
    self.target = hero
    hero.animation_id = @parent.assigned_skill.animation_id
    hero.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    @destroy = true
  end

  def hurt_hero_skill_explode
    for ally in $game_allies.compact
      next if self.target == ally
      next unless in_range?(self, ally, @parent.assigned_skill.range)
      next if ally.actor.dead?
      self.target = ally
      ally.animation_id = @parent.assigned_skill.animation_id
      ally.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    end
    if in_range?(self, $game_player, @parent.assigned_skill.range) and
      self.target != $game_player and !$game_player.actor.dead?
      self.target = $game_player
      $game_player.animation_id = @parent.assigned_skill.animation_id
      $game_player.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    end
    @destroy = true
  end

  def hurt_enemy_weapon_right(enemy)
    return if self.target == enemy
    return if enemy.actor.dead? or enemy.object
    if @parent.actor.weapons[0].ammo1 != nil
      enemy.animation_id = @parent.actor.equips[0].ammo1.animation_id
    else
      enemy.animation_id = @parent.actor.atk_animation_id
    end
    return if enemy.kill_with_weapon > 0 and enemy.kill_with_weapon != @parent.actor.weapon_id or
    enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
    self.target = enemy
    enemy.actor.attack_effect(@parent.actor)
    enemy.jump(0,0) unless enemy.puzzle
    enemy.target = @parent
    @destroy = true
  end

  def hurt_enemy_weapon_left(enemy)
    return if self.target == enemy
    return if enemy.actor.dead? or enemy.object
    if @parent.actor.two_swords_style
      @weapon = @parent.actor.weapons[1]
    else
      @weapon = @parent.actor.weapons[0]
    end
    if @weapon.ammo2 != nil
      enemy.animation_id = @weapon.ammo2.animation_id
    else
      enemy.animation_id = @parent.actor.atk_animation_id2
    end
    return if enemy.kill_with_weapon > 0 and enemy.kill_with_weapon != @weapon.id or
    enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
    self.target = enemy
    enemy.actor.attack_effect(@parent.actor)
    enemy.jump(0,0) unless enemy.puzzle
    enemy.target = @parent
    @destroy = true
  end

  def hurt_enemy_skill(enemy)
    return if self.target == enemy
    return if enemy.actor.dead? or enemy.object
    enemy.animation_id = @parent.assigned_skill.animation_id
    return if enemy.kill_with_weapon > 0 or enemy.kill_with_item > 0 or
    enemy.kill_with_skill > 0 and enemy.kill_with_skill != @parent.assigned_skill.id
    self.target = enemy
    enemy.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    enemy.jump(0,0) unless enemy.puzzle
    enemy.target = @parent
    @destroy = true
  end

  def hurt_enemy_item(enemy)
    return if self.target == enemy
    return if enemy.actor.dead? or enemy.object
    enemy.animation_id = @parent.assigned_item.animation_id
    return if enemy.kill_with_weapon > 0 or enemy.kill_with_skill > 0 or
    enemy.kill_with_item > 0 and enemy.kill_with_item != @parent.assigned_item.id
    self.target = enemy
    enemy.actor.item_effect(@parent.actor, @parent.assigned_item)
    enemy.jump(0,0) unless enemy.puzzle
    enemy.target = @parent
    @destroy = true
  end

  def hurt_enemy_skill_explode
    for monster in $game_monsters.compact
      next if self.target == monster
      next if monster.actor.dead?
      next unless in_range?(self, monster, @parent.assigned_skill.area)
      self.target = monster
      monster.animation_id = @parent.assigned_skill.animation_id
      monster.actor.skill_effect(@parent.actor, @parent.assigned_skill)
      monster.jump(0,0)
      monster.target = @parent
      @destroy = true
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next if self.target == event
      next if event.actor.dead? or event.object
      next unless in_range?(self, event, @parent.assigned_skill.area)
      self.target = event
      event.animation_id = @parent.assigned_skill.animation_id
      next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != @parent.assigned_skill.id
      event.actor.skill_effect(@parent.actor, @parent.assigned_skill)
      event.jump(0,0) unless event.puzzle
      event.target = @parent
    end
    @destroy = true
  end

  def hurt_enemy_item_explode
    for monster in $game_monsters.compact
      next if self.target == monster
      next if monster.actor.dead?
      next unless in_range?(self, monster, @parent.assigned_item.area)
      self.target = monster
      monster.animation_id = @parent.assigned_item.animation_id
      monster.actor.item_effect(@parent.actor, @parent.assigned_item)
      monster.jump(0,0)
      monster.target = @parent
      @destroy = true
    end
    for event in $game_map.events.values
      next unless event.in_battle
      next if self.target == event
      next if event.actor.dead? or event.object
      next unless in_range?(self, event, @parent.assigned_item.area)
      self.target = event
      event.animation_id = @parent.assigned_item.animation_id
      next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and event.kill_with_skill != @parent.assigned_item.id
      event.actor.item_effect(@parent.actor, @parent.assigned_item)
      event.jump(0,0) unless event.puzzle
      event.target = @parent
    end
    @destroy = true
  end

  def hurt_monster_weapon_right(monster)
    return if self.target == monster
    return if monster.actor.dead?
    self.target = monster
    if @parent.actor.weapons[0].ammo1 != nil
      monster.animation_id = @parent.actor.equips[0].ammo1.animation_id
    else
      monster.animation_id = @parent.actor.atk_animation_id
    end
    monster.actor.attack_effect(@parent.actor)
    monster.jump(0,0)
    monster.target = @parent
    @destroy = true
  end

  def hurt_monster_weapon_left(monster)
    return if self.target == monster
    return if monster.actor.dead?
    self.target = monster
    if @parent.actor.two_swords_style
      @weapon = @parent.actor.weapons[1]
    else
      @weapon = @parent.actor.weapons[0]
    end
    if @weapon.ammo2 != nil
      monster.animation_id = @weapon.ammo2.animation_id
    else
      monster.animation_id = @parent.actor.atk_animation_id2
    end
    monster.actor.attack_effect(@parent.actor)
    monster.jump(0,0)
    monster.target = @parent
    @destroy = true
  end

  def hurt_monster_skill(monster)
    return if self.target == monster
    return if monster.actor.dead?
    self.target = monster
    monster.animation_id = @parent.assigned_skill.animation_id
    monster.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    monster.jump(0,0)
    monster.target = @parent
    @destroy = true
  end

  def hurt_monster_item(monster)
    return if self.target == monster
    return if monster.actor.dead?
    self.target = monster
    monster.animation_id = @parent.assigned_item.animation_id
    monster.actor.item_effect(@parent.actor, @parent.assigned_item)
    monster.jump(0,0)
    monster.target = @parent
    @destroy = true
  end

  def map_passable?(x, y)
    return $game_map.range_passable?(x, y)
  end

end

#------------------------------------------------------------------------------
# Game Bomb
#------------------------------------------------------------------------------
class Game_Bomb < Game_Character

  attr_accessor :draw
  attr_accessor :destroy
  attr_accessor :character_name
  attr_accessor :character_index

  def initialize(parent, item)
    super()
    @parent = parent
    @item = item
    @character_name = "IconSet"
    @character_index = @item.icon_index
    @area = @item.area
    @time = @item.delay
    @destroy = false
    @draw = false
    self.priority_type = 2
    jump(0, 0)
    case @parent.direction
    when 2
      moveto(@parent.x, @parent.y+1)
    when 4
      moveto(@parent.x-1, @parent.y)
    when 6
      moveto(@parent.x+1, @parent.y)
    when 8
      moveto(@parent.x, @parent.y-1)
    end
    RPG::SE.new($Requiem_ABS.drop_se[1]).play if $Requiem_ABS.drop_se[1] != ""
    move_random if !$game_map.passable?(@x, @y) or $game_map.events_xy(@x, @y) != []
  end

  def update
    super
    return if @destroy
    if @item.shot_se != nil and Graphics.frame_count % 60 <= 0
      RPG::SE.new(@item.shot_se).play
    end
    @time -= 1 if @time > 0
    explode if @time <= 0
  end

  def explode
    @animation_id = @item.animation_id
    if in_range?(self, $game_player, @area)
      $game_player.actor.item_effect(@parent.actor, @item)
      $game_player.jump(0, 0)
    end
    for monster in $game_monsters.compact
      next unless in_range?(self, monster, @area)
      monster.actor.item_effect(@parent.actor, @item)
      monster.jump(0, 0)
    end
    for event in $game_map.events.values
      next unless event.in_battle and in_range?(self, event, @area)
      event.actor.item_effect(@parent.actor, @item)
      event.jump(0, 0) unless event.puzzle
    end
    for ally in $game_allies.compact
      next if ally.actor.dead?
      next unless in_range?(self, ally, @area)
      ally.actor.item_effect(@parent.actor, @item)
      ally.jump(0, 0)
    end
    @destroy = true
  end

  def screen_z
    return $game_player.screen_z-2
  end

end

#------------------------------------------------------------------------------
# Game Drop
#------------------------------------------------------------------------------
class Game_Drop < Game_Character

  attr_accessor :draw
  attr_accessor :destroy
  attr_accessor :character_name
  attr_accessor :character_index

  def initialize(parent, character_index=0, item=nil, gold=0)
    super()
    @character_name = "IconSet"
    @character_index = character_index
    @item = item
    @gold = gold
    @drop_time = $Requiem_ABS.drop_duration_time
    moveto(parent.x, parent.y)
    RPG::SE.new($Requiem_ABS.drop_se[0]).play if $Requiem_ABS.drop_se[0] != "" and @gold > 0
    RPG::SE.new($Requiem_ABS.drop_se[1]).play if $Requiem_ABS.drop_se[1] != "" and @items != nil
    @destroy = false
    @draw = false
    jump(0,0)
    move_random if !moving?
  end

  def update
    super
    return if @destroy
    @drop_time -= 1 if @drop_time > 0
    @destroy = (@drop_time <= 0)
    return unless Input.trigger?(Input::C) and in_front?($game_player, self)
    get_reward
  end

  def get_reward
    Sound.play_decision
    case @item
    when RPG::Item
      $game_party.gain_item($data_items[@item.id],1)
      $game_player.reward = $data_items[@item.id].name
    when RPG::Weapon
      $game_party.gain_item($data_weapons[@item.id],1)
      $game_player.reward = $data_weapons[@item.id].name
    when RPG::Armor
      $game_party.gain_item($data_armors[@item.id],1)
      $game_player.reward = $data_armors[@item.id].name
    end
    if @gold > 0
      $game_party.gain_gold(@gold)
      $game_player.reward = "#{Vocab.gold} #{@gold}"
    end
    @destroy = true
  end

  def screen_z
    return $game_player.screen_z-2
  end

end

#------------------------------------------------------------------------------
# Sprite Base
#------------------------------------------------------------------------------
class Sprite_Base

  attr_reader :animation_duration

  alias requiem_abs_spbase_initialize initialize
  alias requiem_abs_spbase_update update
  alias requiem_abs_spbase_dispose dispose

  def initialize(viewport = nil)
    requiem_abs_spbase_initialize(viewport)
    @_damage_duration = 0
    @_hit_duration = 0
    @_reward_duration = 0
  end

  def update
    requiem_abs_spbase_update
    update_show_dmg
    update_show_hit
    update_show_reward
  end

  def animation_set_sprites(frame)
    cell_data = frame.cell_data
    for i in 0...15
      sprite = @animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern == nil or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @animation_bitmap1
      else
        sprite.bitmap = @animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192, pattern % 100 / 5 * 192, 192, 192)
      if @animation_mirror
        sprite.x = @animation_ox - cell_data[i, 1] / $Requiem_ABS.animations_divide
        sprite.y = @animation_oy + cell_data[i, 2] / $Requiem_ABS.animations_divide
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = @animation_ox + cell_data[i, 1] / $Requiem_ABS.animations_divide
        sprite.y = @animation_oy + cell_data[i, 2] / $Requiem_ABS.animations_divide
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + 300 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / (100.0 * $Requiem_ABS.animations_divide)
      sprite.zoom_y = cell_data[i, 3] / (100.0 * $Requiem_ABS.animations_divide)
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end

  def update_show_dmg
    if @_damage_duration > 0
      @_damage_duration -=1
      @_damage_sprite.y -= 1
      @_damage_sprite.x = self.x
    elsif @_damage_duration <= 0 and @_damage_sprite != nil and !@_damage_sprite.disposed?
      @_damage_sprite.y -= 1
      @_damage_sprite.opacity -= 5
      dispose_damage if @_damage_sprite.opacity <= 0
    end
    if @character.actor != nil and @character.actor.damage != 0
      return if @character.is_a?(Game_Event) and @character.puzzle
      damage(@character.actor.damage, @character.actor.critical, @character.actor.combo, @character.actor.reflect)
      @character.actor.damage = 0
      @character.actor.critical = @character.actor.combo = @character.actor.reflect = false
    end
  end

  def update_show_hit
    if @_hit_duration > 0
      @_hit_duration -=1
    elsif @_hit_duration <= 0 and @_hit_sprite != nil and !@_hit_sprite.disposed?
      @_hit_sprite.opacity -= 5
      dispose_hit if @_hit_sprite.opacity <= 0
    end
    if @character.is_a?(Game_Player) and @character.hit != nil
      hit(@character.hit)
      @character.hit = nil
    end
  end

  def update_show_reward
    if @_reward_duration > 0
      @_reward_duration -= 1
    elsif @_reward_duration <= 0 and @_reward_sprite != nil and !@_reward_sprite.disposed?
      @_reward_sprite.opacity -= 5
      dispose_reward if @_reward_sprite.opacity <= 0
    end
    if $game_player.reward != nil and $Requiem_ABS.show_reward
      reward($game_player.reward)
      $game_player.reward = nil
    end
  end

  def update_show_state_ani
    return if @character.actor.nil?
    for state in @character.actor.states
      next if state.nil? or state.animation_id <= 0
      if @character.ani_time <= 0
        @character.animation_id = state.animation_id
        @character.ani_time = $data_animations[@character.animation_id].frame_max * 4 + 1
      end
    end
  end

  def damage(value, critical, combo, reflect)
    dispose_damage
    damage_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
    bitmap = Bitmap.new(160, ($Requiem_ABS.damage_properties["Damage"][1]*2)+10)
    bitmap.font.name = $Requiem_ABS.damage_properties["Damage"][0]
    bitmap.font.size = $Requiem_ABS.damage_properties["Damage"][1]
    bitmap.font.bold = $Requiem_ABS.damage_properties["Damage"][2]
    bitmap.font.italic = $Requiem_ABS.damage_properties["Damage"][3]
    bitmap.font.shadow = false
    if value.is_a?(Numeric) and value <= 0
      color = $Requiem_ABS.damage_properties["Colors"][1]
    else
      color = $Requiem_ABS.damage_properties["Colors"][0]
    end
    bitmap.draw_outlined_text(0, bitmap.font.size+5, bitmap.width, bitmap.font.size, damage_string, 1, color)
    if reflect
      color = $Requiem_ABS.damage_properties["Colors"][5]
      bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, $Requiem_ABS.damage_properties["Texts"][6], 1, color)
    elsif combo
      color = $Requiem_ABS.damage_properties["Colors"][3]
      bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size,$Requiem_ABS.damage_properties["Texts"][2], 1, color)
    elsif critical
      color = $Requiem_ABS.damage_properties["Colors"][2]
      bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, $Requiem_ABS.damage_properties["Texts"][1], 1, color)
    end
    @_damage_sprite = Sprite.new(self.viewport)
    @_damage_sprite.bitmap = bitmap
    @_damage_sprite.ox = bitmap.width/2
    @_damage_sprite.oy = bitmap.height*2
    @_damage_sprite.x = self.x
    @_damage_sprite.y = self.y
    @_damage_sprite.z = 999999
    @_damage_duration = 30
  end

  def hit(value)
    dispose_hit
    hit_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
    bitmap = Bitmap.new(160, $Requiem_ABS.damage_properties["Hits"][1])
    bitmap.font.name = $Requiem_ABS.damage_properties["Hits"][0]
    bitmap.font.size = $Requiem_ABS.damage_properties["Hits"][1]
    bitmap.font.bold = $Requiem_ABS.damage_properties["Hits"][2]
    bitmap.font.italic = $Requiem_ABS.damage_properties["Hits"][3]
    bitmap.font.shadow = false
    color = $Requiem_ABS.damage_properties["Colors"][4]
    bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size,"#{hit_string}" "#{$Requiem_ABS.damage_properties["Texts"][5]}", 2, color)
    @_hit_sprite = Sprite.new(self.viewport)
    @_hit_sprite.bitmap = bitmap
    @_hit_sprite.x = Graphics.width-bitmap.width-10
    @_hit_sprite.y = (Graphics.height/2)-bitmap.font.size
    @_hit_sprite.z = 999999
    @_hit_duration = 60
  end

  def reward(reward)
    dispose_reward
    bitmap = Bitmap.new(200, $Requiem_ABS.damage_properties["Reward"][1])
    bitmap.font.name = $Requiem_ABS.damage_properties["Reward"][0]
    bitmap.font.size = $Requiem_ABS.damage_properties["Reward"][1]
    bitmap.font.bold = $Requiem_ABS.damage_properties["Reward"][2]
    bitmap.font.italic = $Requiem_ABS.damage_properties["Reward"][3]
    bitmap.font.shadow = false
    color = $Requiem_ABS.damage_properties["Colors"][0]
    bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, reward, 0, color)
    @_reward_sprite = Sprite.new(self.viewport)
    @_reward_sprite.bitmap = bitmap
    @_reward_sprite.x = 10
    @_reward_sprite.y = (Graphics.height/2)-bitmap.font.size
    @_reward_sprite.z = 999999
    @_reward_duration = 300
  end

  def dispose
    requiem_abs_spbase_dispose
    dispose_damage
    dispose_hit
    dispose_reward
  end

  def dispose_damage
    return if @_damage_sprite.nil?
    @_damage_sprite.bitmap.dispose
    @_damage_sprite.dispose
    @_damage_sprite = nil
  end

  def dispose_hit
    return if @_hit_sprite.nil?
    @_hit_sprite.bitmap.dispose
    @_hit_sprite.dispose
    @_hit_sprite = nil
  end

  def dispose_reward
    return if @_reward_sprite.nil?
    @_reward_sprite.bitmap.dispose
    @_reward_sprite.dispose
    @_reward_sprite = nil
  end

end

#------------------------------------------------------------------------------
# Sprite Drop
#------------------------------------------------------------------------------
class Sprite_Drop < Sprite_Base

  attr_accessor :character

  def initialize(viewport, character=nil)
    super(viewport)
    @character = character
    update
  end

  def update
    super
    update_bitmap
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    if @character.animation_id != 0
      start_animation($data_animations[@character.animation_id])
      @character.animation_id = 0
    end
  end

  def update_bitmap
    return if @character_name == @character.character_name
    @character_name = @character.character_name
    self.bitmap = Cache.system(@character_name)
    self.ox = 12
    self.oy = 24
    sx = @character.character_index % 16 * 24
    sy = @character.character_index / 16 * 24
    self.src_rect.set(sx, sy, 24, 24)
  end

end

#------------------------------------------------------------------------------
# Sprite Weapon
#------------------------------------------------------------------------------
class Sprite_Weapon < Sprite_Base

  attr_accessor :character

  def initialize(viewport, character=nil)
    super(viewport)
    @character = character
    self.visible = false
    create_bitmap
    update
  end

  def update
    super
    return unless $Requiem_ABS.allow_weapons_graphics
    return if @character.actor.nil?
    return if @character.is_a?(Game_Ally) and @character.map_id != $game_map.map_id
    self.visible = (@character.anime_attack > 0)
    update_src_rect
    update_movement
  end

  def create_bitmap
    self.bitmap = Cache.system("Iconset")
    self.ox = 12
    self.oy = 24
    self.zoom_x = 0.80
    self.zoom_y = 0.80
  end

  def update_src_rect
    sx = weapon_index % 16 * 24
    sy = weapon_index / 16 * 24
    self.src_rect.set(sx, sy, 24, 24)
  end

  def update_movement
    case @character.direction
    when 2
      self.x = @character.screen_x-6
      self.z = @character.screen_z+2
      self.mirror = false
      change_angle(180, 135, 90)
    when 4
      self.x = @character.screen_x-10
      self.z = @character.screen_z-1
      self.mirror = false
      change_angle(-45, 0, 45)
    when 6
      self.x = @character.screen_x+10
      self.z = @character.screen_z+2
      self.mirror = true
      change_angle(45, 0, -45)
    when 8
      self.x = @character.screen_x+10
      self.z = @character.screen_z-1
      self.mirror = true
      change_angle(45, 0, -45)
    end
    self.y = @character.screen_y-4
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
  end

  def change_angle(a, b, c)
    if @character.anime_attack >= 20
      self.angle = a
    elsif @character.anime_attack >= 15
      self.angle = b
    elsif @character.anime_attack >= 10
      self.angle = c
    end
  end

  def weapon_index
    return 0 if @character.actor.nil?
    if @character.actor.is_a?(Game_Actor) and @character.right_attack_on and @character.actor.equips[0] != nil
      return @character.actor.equips[0].icon_index
    elsif @character.actor.is_a?(Game_Actor) and @character.left_attack_on
      if @character.actor.two_swords_style and @character.actor.equips[1] != nil
        return @character.actor.equips[1].icon_index
      elsif @character.actor.two_hands_legal? and @character.actor.equips[0] != nil and @character.actor.equips[0].ranged?
        return @character.actor.equips[0].icon_index
      end
    elsif @character.actor.is_a?(Game_Enemy) and @character.actor.weapon_icon > 0
      return @character.actor.weapon_icon
    end
    return 0
  end

end

#------------------------------------------------------------------------------
# Sprite Shield
#------------------------------------------------------------------------------
class Sprite_Shield < Sprite_Base

  attr_accessor :character

  def initialize(viewport, character = nil)
    super(viewport)
    @character = character
    self.visible = false
    create_bitmap
    update
  end

  def update
    super
    return unless $Requiem_ABS.allow_shields_graphics
    return if @character.actor.nil?
    return if @character.is_a?(Game_Ally) and @character.map_id != $game_map.map_id
    self.visible = @character.actor.defending
    update_src_rect
    update_movement
    moving_with_shield
  end

  def create_bitmap
    self.bitmap = Cache.system("Iconset")
    self.ox = 12
    self.oy = 24
    self.zoom_x = 0.80
    self.zoom_y = 0.80
  end

  def update_src_rect
    sx = shield_index % 16 * 24
    sy = shield_index / 16 * 24
    self.src_rect.set(sx, sy, 24, 24)
  end

  def update_movement
    case @character.direction
    when 2
      self.mirror = true
      self.x = @character.screen_x+6
      self.z = @character.screen_z+1
    when 4
      self.mirror = false
      self.x = @character.screen_x-6
      self.z = @character.screen_z+1
    when 6
      self.mirror = true
      self.x = @character.screen_x+6
      self.z = @character.screen_z-1
    when 8
      self.mirror = false
      self.x = @character.screen_x-6
      self.z = @character.screen_z-1
    end
    self.y = @character.screen_y
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
  end

  def moving_with_shield
    if @character.moving?
      self.wave_amp = 1
      self.wave_length = 1
      self.wave_speed = 6
    else
      self.wave_amp = 0
    end
  end

  def shield_index
    return 0 if @character.actor.nil?
    if @character.actor.is_a?(Game_Actor) and [email protected]_swords_style and @character.actor.armor1_id > 0
      return @character.actor.armors[0].icon_index
    elsif @character.actor.is_a?(Game_Enemy) and @character.actor.shield_icon > 0
      return @character.actor.shield_icon
    end
    return 0
  end

end

#------------------------------------------------------------------------------
# Spriteset Map
#------------------------------------------------------------------------------
class Spriteset_Map

  alias requiem_abs_sp_map_create_characters create_characters
  alias requiem_abs_sp_map_dispose_characters dispose_characters

  def create_characters
    @allies_sprites = []
    for ally in $game_allies.compact
      @allies_sprites.push(Sprite_Character.new(@viewport1, ally))
    end
    @range_sprites = []
    for range in $game_range.compact
      next unless $game_map.in_range?(range)
      @range_sprites.push(Sprite_Character.new(@viewport1, range))
    end
    @drop_sprites = []
    for drop in $game_drop.compact
      next unless $game_map.in_range?(drop)
      @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
    end
    for bomb in $game_bomb.compact
      next unless $game_map.in_range?(bomb)
      @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
    end
    @weapon_sprites = []
    @shield_sprites = []
    @weapon_sprites.push(Sprite_Weapon.new(@viewport1, $game_player))
    @shield_sprites.push(Sprite_Shield.new(@viewport1, $game_player))
    for ally in $game_allies.compact
      @weapon_sprites.push(Sprite_Weapon.new(@viewport1, ally))
      @shield_sprites.push(Sprite_Shield.new(@viewport1, ally))
    end
    for i in $game_map.events.keys.sort
      @weapon_sprites.push(Sprite_Weapon.new(@viewport1, $game_map.events[i]))
      @shield_sprites.push(Sprite_Shield.new(@viewport1, $game_map.events[i]))
    end
    @monsters_sprites = []
    for monster in $game_monsters.compact
      @monsters_sprites.push(Sprite_Character.new(@viewport1, monster))
      @weapon_sprites.push(Sprite_Weapon.new(@viewport1, monster))
      @shield_sprites.push(Sprite_Shield.new(@viewport1, monster))
    end
    requiem_abs_sp_map_create_characters
  end

  def update_characters
    for sprite in @character_sprites
      if sprite.character.is_a?(Game_Event)
        sprite.update if $game_map.in_range?(sprite.character)
      else
        sprite.update
      end
    end
    for ally in @allies_sprites.compact
      if ally.character.destroy and !ally.disposed?
        ally.dispose
        $game_allies.delete(ally.character)
        @allies_sprites.delete(ally)
      elsif !ally.disposed?
        ally.update if $game_map.in_range?(ally.character)
      end
    end
    for monster in @monsters_sprites.compact
      if monster.character.destroy and !monster.character.respawn and !monster.disposed?
        monster.dispose
        $game_monsters.delete(monster.character)
        @monsters_sprites.delete(monster)
      elsif !monster.disposed?
        monster.update if $game_map.in_range?(monster.character)
      end
    end
    for range in @range_sprites.compact
      if range.character.destroy and !range.disposed?
        range.dispose
        $game_range.delete(range.character)
        @range_sprites.delete(range)
      elsif !range.disposed?
        range.update if $game_map.in_range?(range.character)
      end
    end
    for drop in @drop_sprites.compact
      if drop.character.destroy and !drop.disposed?
        drop.update
        drop.character.character_name = ""
        unless drop.animation?
          drop.dispose
          $game_drop.delete(drop.character)
          $game_bomb.delete(drop.character)
          @drop_sprites.delete(drop)
        end
      elsif !drop.disposed?
        drop.update if $game_map.in_range?(drop.character)
      end
    end
    for ally in $game_allies.compact
      next if ally.draw
      @allies_sprites.push(Sprite_Character.new(@viewport1, ally))
      @weapon_sprites.push(Sprite_Weapon.new(@viewport1, ally))
      @shield_sprites.push(Sprite_Shield.new(@viewport1 ,ally))
      ally.draw = true
    end
    for range in $game_range.compact
      next unless $game_map.in_range?(range)
      next if range.draw
      @range_sprites.push(Sprite_Character.new(@viewport1, range))
      range.draw = true
    end
    for drop in $game_drop.compact
      next unless $game_map.in_range?(drop)
      next if drop.draw
      @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
      drop.draw = true
    end
    for bomb in $game_bomb.compact
      next unless $game_map.in_range?(bomb)
      next if bomb.draw
      @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
      bomb.draw = true
    end
    for weapon in @weapon_sprites.compact
      next unless $game_map.in_range?(weapon.character)
      weapon.update
    end
    for shield in @shield_sprites.compact
      next unless $game_map.in_range?(shield.character)
      shield.update
    end
  end

  def dispose_characters
    requiem_abs_sp_map_dispose_characters
    @allies_sprites.compact.each { |i| i.dispose }
    @monsters_sprites.compact.each { |i| i.dispose }
    @range_sprites.compact.each { |i| i.dispose }
    @drop_sprites.compact.each { |i| i.dispose }
    @weapon_sprites.compact.each { |i| i.dispose }
    @shield_sprites.compact.each { |i| i.dispose }
  end

  def refresh_characters
    dispose_characters
    create_characters
  end

end

#------------------------------------------------------------------------------
# Window Base
#------------------------------------------------------------------------------
class Window_Base < Window

  def draw_actor_head(actor, x, y, enabled=true)
    char_name = actor.character_name
    char_index = actor.character_index
    bitmap = Cache.character(char_name)
    sign = char_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    enbl = (enabled ? 255 : 128)
    src_rect = Rect.new((char_index%4*3+1)*cw, (char_index/4*4)*ch, cw, ch/3*2)
    self.contents.blt(x, y, bitmap, src_rect, enbl)
  end

end

#------------------------------------------------------------------------------
# Scene Title
#------------------------------------------------------------------------------
class Scene_Title < Scene_Base

  alias requiem_abs_scenetitle_create_game_objects create_game_objects
  alias requiem_abs_scenetitle_command_new_game command_new_game

  def create_game_objects
    $game_monsters = []
    $game_allies = []
    $game_range = []
    $game_drop = []
    $game_bomb = []
    requiem_abs_scenetitle_create_game_objects
    $Requiem_ABS = Requiem_ABS.new
  end

  def command_new_game
    requiem_abs_scenetitle_command_new_game
    for ally in $game_allies.compact
      ally.map_id = $data_system.start_map_id
      ally.moveto($data_system.start_x, $data_system.start_y)
      ally.move_random
    end
  end

end

#------------------------------------------------------------------------------
# Scene Map
#------------------------------------------------------------------------------
class Scene_Map < Scene_Base

  alias requiem_abs_scenemap_update update

  def update
    requiem_abs_scenemap_update
    for ally in $game_allies.compact
      ally.update if $game_map.in_range?(ally)
    end
    for monster in $game_monsters.compact
      monster.update if $game_map.in_range?(monster)
    end
    for range in $game_range.compact
      range.update if $game_map.in_range?(range)
    end
    for drop in $game_drop.compact
      drop.update if $game_map.in_range?(drop)
    end
    for bomb in $game_bomb.compact
      bomb.update if $game_map.in_range?(bomb)
    end
  end

  def update_encounter
  end

  def refresh_sprites
    @spriteset.refresh_characters
    Cache.clear
  end

end

#------------------------------------------------------------------------------
# Scene Item
#------------------------------------------------------------------------------
class Window_Item < Window_Selectable

  def update_help
    if $scene.is_a?(Scene_Item) and $scene.message != ""
      @help_window.set_text($scene.message)
    else
      @help_window.set_text(item == nil ? "" : item.description)
    end
  end

end

#------------------------------------------------------------------------------
class Scene_Item < Scene_Base

  attr_accessor :message
  attr_accessor :delay

  alias requiem_abs_sitem_start start
  alias requiem_abs_sitem_update update
  alias requiem_abs_sitem_update_item_selection update_item_selection

  def start
    requiem_abs_sitem_start
    @actor = $game_party.members[0]
    @message = ""
    @delay = 0
  end

  def update
    requiem_abs_sitem_update
    if @delay <= 0
      @message = ""
    else
      @delay -= 1
    end
  end

  def update_item_selection
    requiem_abs_sitem_update_item_selection
    for button in @actor.item_hotkeys.keys
      next unless @item_window.item.is_a?(RPG::Item)
      next unless Input.trigger?(button)
      Sound.play_decision
      @actor.item_hotkeys[button] = @item_window.item.id
      @message = $Requiem_ABS.memorized_text
      @delay = 120
    end
  end

end

#------------------------------------------------------------------------------
# Scene Skill
#------------------------------------------------------------------------------
class Window_Skill < Window_Selectable

  def update_help
    if $scene.is_a?(Scene_Skill) and $scene.message != ""
      @help_window.set_text($scene.message)
    else
      @help_window.set_text(skill == nil ? "" : skill.description)
    end
  end

end

#------------------------------------------------------------------------------
class Scene_Skill < Scene_Base

  attr_accessor :message
  attr_accessor :delay

  alias requiem_abs_sskill_start start
  alias requiem_abs_sskill_update update
  alias requiem_abs_sskill_update_skill_selection update_skill_selection

  def start
    requiem_abs_sskill_start
    @message = ""
    @delay = 0
  end

  def update
    requiem_abs_sskill_update
    if @delay <= 0
      @message = ""
    else
      @delay -= 1
    end
  end

  def update_skill_selection
    requiem_abs_sskill_update_skill_selection
    for button in @actor.skill_hotkeys.keys
      next unless Input.trigger?(button)
      Sound.play_decision
      @actor.skill_hotkeys[button] = @skill_window.skill.id
      @message = $Requiem_ABS.memorized_text
      @delay = 120
    end
  end

end

#------------------------------------------------------------------------------
# Scene File
#------------------------------------------------------------------------------
class Scene_File < Scene_Base

  alias requiem_abs_sfile_do_load do_load
  alias requiem_abs_sfile_write_save_data write_save_data
  alias requiem_abs_sfile_read_save_data read_save_data

  def do_load
    requiem_abs_sfile_do_load
    $game_player.refresh
    for ally in $game_allies.compact
      ally.refresh
    end
  end

  def write_save_data(file)
    requiem_abs_sfile_write_save_data(file)
    Marshal.dump($game_allies, file)
    Marshal.dump($game_monsters, file)
    Marshal.dump($game_range, file)
    Marshal.dump($game_drop, file)
    Marshal.dump($game_bomb, file)
  end

  def read_save_data(file)
    requiem_abs_sfile_read_save_data(file)
    $game_allies = Marshal.load(file)
    $game_monsters = Marshal.load(file)
    $game_range = Marshal.load(file)
    $game_drop = Marshal.load(file)
    $game_bomb = Marshal.load(file)
  end

end

#------------------------------------------------------------------------------
# End of ABS
#------------------------------------------------------------------------------
end