VX to XP

[Rusk]

Gut hier ist es:
Jeder Spoiler ist ein eigener Script und gehört vor der Main.
Der Spoiler "Requiem ABS 5" ist das eigentliche Kampfsystem.

Code:

#==============================================================================
# Input Module
#==============================================================================
module Input
  
  Mouse_Left = 1
  Mouse_Right = 2
  Mouse_Middle = 4
  
  Back = 8
  Tab = 9
  Enter = 13
  Shift = 16
  Ctrl = 17
  Alt = 18
  CapsLock = 20
  Esc = 27
  Space = 32
  PGUP = 33
  PGDN = 34
  End = 35
  Home = 36
  Left = 37
  Up = 38
  Right = 39
  Down = 40
  PrintScreen = 44
  Insert = 45
  Delete = 46
  
  Numberkeys = {}
  Numberkeys[0] = 48
  Numberkeys[1] = 49
  Numberkeys[2] = 50
  Numberkeys[3] = 51
  Numberkeys[4] = 52
  Numberkeys[5] = 53
  Numberkeys[6] = 54
  Numberkeys[7] = 55
  Numberkeys[8] = 56
  Numberkeys[9] = 57
  
  Letters = {}
  Letters["A"] = 65
  Letters["B"] = 66
  Letters["C"] = 67
  Letters["D"] = 68
  Letters["E"] = 69
  Letters["F"] = 70
  Letters["G"] = 71
  Letters["H"] = 72
  Letters["I"] = 73
  Letters["J"] = 74
  Letters["K"] = 75
  Letters["L"] = 76
  Letters["M"] = 77
  Letters["N"] = 78
  Letters["O"] = 79
  Letters["P"] = 80
  Letters["Q"] = 81
  Letters["R"] = 82
  Letters["S"] = 83
  Letters["T"] = 84
  Letters["U"] = 85
  Letters["V"] = 86
  Letters["W"] = 87
  Letters["X"] = 88
  Letters["Y"] = 89
  Letters["Z"] = 90
  
  LWin = 91
  RWin = 92
  Apps = 93
  
  Numberpad = {}
  Numberpad[0] = 96
  Numberpad[1] = 97
  Numberpad[2] = 98
  Numberpad[3] = 99
  Numberpad[4] = 100
  Numberpad[5] = 101
  Numberpad[6] = 102
  Numberpad[7] = 103
  Numberpad[8] = 104
  Numberpad[9] = 105
  Multiply = 106
  Add = 107
  Subtract = 109
  Decimal = 110
  Divide = 111
  
  Fkeys = {}
  Fkeys[1] = 112
  Fkeys[2] = 113
  Fkeys[3] = 114
  Fkeys[4] = 115
  Fkeys[5] = 116
  Fkeys[6] = 117
  Fkeys[7] = 118
  Fkeys[8] = 119
  Fkeys[9] = 120
  Fkeys[10] = 121
  Fkeys[11] = 122
  Fkeys[12] = 123
  
  NumLock = 144
  ScrollLock = 145 
  LShift = 160
  RShift = 161
  LControl = 162
  RControl = 163
  LAlt = 164
  RAlt = 165
  
  Collon = 186
  Equal = 187
  Comma = 188
  Underscore = 189
  Dot = 190
  Backslash = 191
  Uncle = 192
  LB = 219
  Bar = 220
  RB = 221
  Quote = 222
  
  @time = Array.new(256, 0)
  @press = Array.new(256, false)
  @trigger = Array.new(256, false)
  @repeat = Array.new(256, false)
  @release = Array.new(256, false)
  @dirs = [0, 0]
  
  InputInitialize = Win32API.new("Input", 'InputInitialize', 'LLLLLL', '')
  InputUpdate = Win32API.new("Input", 'InputUpdate', '', '')
  
  REG_KVALUES = {0=>32,1=>13,2=>27,3=>96,4=>16,5=>90,6=>88,7=>67,8=>86,9=>66,
                 10=>65,11=>83,12=>68,13=>81,14=>87}
                 
  DEFAULT_KEYS = {11=>[16,90],12=>[27,88,96],13=>[13,32],14=>[65],15=>[83],
                  16=>[68],17=>[81],18=>[87]}
  
  def convert_keys(key)
    begin
      keys = []
      rkey = 'HKEY_CURRENT_USER\\Software\\Enterbrain\\RGSS'
      data = Registry.read_entry(rkey, 'ButtonAssign')[10, 25].scan(/./)
      15.times {|i| keys.push(REG_KVALUES[i]) if key == data[i].unpack('C')[0]}
      keys
    rescue
      DEFAULT_KEYS[key] rescue []
    end
  end   
  
  module_function :convert_keys
  
  LEFT = 37
  UP = 38
  RIGHT = 39
  DOWN = 40
  A = convert_keys(11)
  B = [45] + convert_keys(12)
  C = convert_keys(13)
  X = convert_keys(14)
  Y = convert_keys(15)
  Z = convert_keys(16)
  L = [33] + convert_keys(17)
  R = [34] + convert_keys(18)
  SHIFT = 16
  CTRL = 17
  ALT = 18
  F5 = 116
  F6 = 117
  F7 = 118
  F8 = 119
  F9 = 120
  
  InputInitialize.call(@time.object_id, @press.object_id, @trigger.object_id,
  @repeat.object_id,  @release.object_id, @dirs.object_id)
  
  def self.update
    InputUpdate.call
  end
  
  def self.trigger?(id)
    @trigger.indexes(*id.to_a).include?(true)
  end
  
  def self.press?(id)
    @press.indexes(*id.to_a).include?(true)
  end
  
  def self.triggerd?(what)
    if triggered.include?(what)
      return true
    end
  end
  
  def self.triggered
    array = Array.new
    @trigger.each_index {|i| array.push(i) if @trigger[i]}
    array
  end
  
  def self.pressed?(what)
    if pressed.include?(what)
      return true
    end
  end
  
  def self.pressed
    array = Array.new
    @press.each_index {|i| array.push(i) if @press[i]}
    array
  end
  
  def self.repeat?(id)
    @repeat.indexes(*id.to_a).include?(true)
  end
  
  def self.repeated
    array = Array.new
    @repeat.each_index {|i| array.push(i) if @repeat[i]}
    array
  end
  
  def self.release?(id)
    @release.indexes(*id.to_a).include?(true)
  end
  
  def self.released
    array = Array.new
    @release.each_index {|i| array.push(i) if @release[i]}
    array
  end
  
  def self.dir4
    @dirs[0]
  end
  
  def self.dir8
    @dirs[1]
  end

  KEYS_NAMES = {1=>'Mouse Left',2=>'Mouse Right',3=>'Cancel',
  4=>'Mouse Middle',5=>'Mouse 4th',6=>'Mouse 5th',8=>'Backspace',9=>'Tab',
  12=>'Clear',13=>'Enter',16=>'Shift',17=>'Control',18=>'Alt',19=>'Pause',
  20=>'Capitals Lock',21=>'Kana',23=>'Junja',24=>'Final',25=>'Kanji',
  27=>'Escape',28=>'Convert',29=>'Non Convert',30=>'Accept',31=>'Mode Change',
  32=>'Space',33=>'Page Up',34=>'Page Down',35=>'End',36=>'Home',37=>'Left',
  38=>'Up',39=>'Right',40=>'Down',41=>'Select',42=>'Print',43=>'Execute',
  44=>'PrintScreen',45=>'Insert',46=>'Delete',47=>'Help',48=>'0',49=>'1',50=>'2',
  51=>'3',52=>'4',53=>'5',54=>'6',55=>'7',56=>'8',57=>'9',65=>'A',66=>'B',
  67=>'C',68=>'D',69=>'E',70=>'F',71=>'G',72=>'H',73=>'I',74=>'J',75=>'K',
  76=>'L',77=>'M',78=>'N',79=>'O',80=>'P',81=>'Q',82=>'R',83=>'S',84=>'T',
  85=>'U',86=>'V',87=>'W',88=>'X',89=>'Y',90=>'Z',91=>'Left Windows',
  92=>'Right Windows',93=>'Application',95=>'Sleep',96=>'PAD 0',97=>'PAD 1',
  98=>'PAD 2',99=>'PAD 3',100=>'PAD 4',101=>'PAD 5',102=>'PAD 6',103=>'PAD 7',
  104=>'PAD 8',105=>'PAD 9',106=>'*',107=>'+',108=>'Separator',109=>'-',110=>'.',
  111=>'/',112=>'F1',113=>'F2',114=>'F3',115=>'F4',116=>'F5',117=>'F6',118=>'F7',
  119=>'F8',120=>'F9',121=>'F10',122=>'F11',123=>'F12',124=>'F13',125=>'F14',
  126=>'F15',127=>'F16',128=>'F17',129=>'F18',130=>'F19',131=>'F20',132=>'F21',
  133=>'F22',134=>'F23',135=>'F24',144=>'Number Lock',145=>'Scroll Lock',
  146=>'OEM 15',147=>'OEM 16',148=>'OEM 17',149=>'OEM 18',150=>'OEM 19',
  160=>'Left Shift',161=>'Right Shift',162=>' Left Control',163=>'Right Control',
  164=>' Left Alt',165=>'Right Alt',166=>'Browser Back',167=>'Browser Forward',
  168=>'Browser Refresh',169=>'Browser Stop',170=>'Browser Search',
  171=>'Browser Favorites',172=>'Browser Home',173=>'Volume Mute',
  174=>'Volume Down',175=>'Volume Up',176=>'Media Next Track',
  177=>'Media Previous Track',178=>'Media Stop',179=>'Media Play Pause',
  180=>'Launch Mail',181=>'Launch Media Select',182=>'Launch Application',
  183=>'Launch Application',186=>'OEM 1',187=>'OEM 2',188=>'OEM 3',189=>'OEM 4',
  190=>'OEM 5',191=>'OEM 6',192=>'OEM 7',219=>'OEM 8',220=>'OEM 9',221=>'OEM 10',
  222=>'OEM 11',223=>'OEM 13',225=>'OEM 20',226=>'OEM 14',227=>'OEM 21',
  228=>'OEM 22',229=>'Proccess',230=>'OEM 23',232=>'OEM 24',240=>'OEM 25',
  241=>'OEM 26',242=>'OEM 27',243=>'OEM 28',244=>'OEM 29',245=>'OEM 30',
  246=>'ATTN',247=>'CRSEL',248=>'EXSEL',249=>'EREOF',250=>'Play',251=>'Zoom',
  253=>'PA1',254=>'OEM Clear'}
  
  def self.name?(id)
    return (KEYS_NAMES[id].nil? ? '???' : KEYS_NAMES[id])
  end
  
end

#-----------------------------------------------------------------------------
module Registry
  
  module_function
  
  RegCloseKey = Win32API.new('advapi32', 'RegCloseKey', 'L', 'L')
  RegOpenKeyExA = Win32API.new('advapi32', 'RegOpenKeyExA', 'LPLLP', 'L')
  RegQueryValueExA = Win32API.new('advapi32', 'RegQueryValueExA','LPLPPP','L')
  HKEYS = {'HKEY_CLASSES_ROOT' => 0x80000000,'HKEY_CURRENT_USER' =>0x80000001,
  'HKEY_LOCAL_MACHINE' => 0x80000002, 'HKEY_USERS' => 0x80000003, 
  'HKEY_CURRENT_CONFIG' => 0x80000005}
  
  def read_entry(key, entry)
    key.sub!(/(.*?)\\/, '')
    if HKEYS[$1] != nil
      hkey = HKEYS[$1]
    else
      return nil
    end
    opened, type, size = [0].pack('V'), [0].pack('V'), [0].pack('V')
    RegOpenKeyExA.call(hkey, key, 0, 131097, opened)
    opened = (opened + [0].pack('V')).unpack('V')[0]
    RegQueryValueExA.call(opened, entry, 0, type, 0, size)
    data = ' ' * (size + [0].pack('V')).unpack('V')[0]
    RegQueryValueExA.call(opened, entry, 0, type, data, size)
    RegCloseKey.call(opened)
    data = data[0, (size + [0].pack('V')).unpack('V')[0]]
    type = (type += [0].pack('V')).unpack('V')[0]
    case type
    when 1
      data.chop
    when 2
      data.chop.gsub(/%([^%]+)%/) { ENV[$1] || $& }
    when 3
      data
    when 4
      (data += [0].pack('V')).unpack('V')[0]
    when 5
      data.unpack('N')[0]
    when 7
      data.split(/\0/)
    when 11
      (data.unpack('VV')[1] << 32) | data[0]
    else
      nil
    end
  end
  
end

Code:

#==============================================================================
# Requiem Masterpiece
#==============================================================================
# This module is necessary to activate all others scripts of Requiem
#------------------------------------------------------------------------------
module Requiem_Masterpiece
  
  Version = 1.0
  
  @scripts = {}
  
  def self.register(script, version, date)
    @scripts[script] = [version, date]
  end
  
  def self.enabled?(script, version = nil)
    if version != nil and @scripts.include?(script)
      return true if @scripts[script][0] >= version
    end
    return true if @scripts[script] != nil
    return false
  end
  
end

Code:

#==============================================================================
# Requiem ABS Version 5.0
#==============================================================================
#------------------------------------------------------------------------------
# Credits: Vlad | Email: demon_of_lust@live.com
#------------------------------------------------------------------------------

# To create an enemy, put the following comments in a event on map:

# Enemy X - Change X for a ID of a monster in Database;
# Die Erase - Erase the enemy when it dies;
# Die Self Switch A - Turn On the Self Switch A when enemy dies;
# Die Self Switch B - Turn On the Self Switch B when enemy dies;
# Die Self Switch C - Turn On the Self Switch C when enemy dies;
# Die Self Switch D - Turn On the Self Switch D when enemy dies;
# Die Switch X - Turn On the Switch X when enemy dies;
# Die Variable X - Increase +1 to variable X;
# Follow X - Change X for range of sight of the enemy, to it follow the player automatically
# Kill With Weapon X - The enemy will die only if be attacked with weapon X
# Kill With Skill X - The enemy will die only if be attacked with skill X
# Kill With Item X - The enemy will die only if be attacked with item X
# Object - Makes the enemy be an object, and impossible to kill
# Puzzle - Makes the enemy be an puzzle, it can be killed but allies don't follow it, the damage and hp bar is not showed
# Respawn X - Makes the enemy respawns automatically after X frames
# Boss - Shows the Boss HP Bar

#------------------------------------------------------------------------------
Requiem_Masterpiece.register("Requiem ABS", 5.0, "29/03/2009")
#------------------------------------------------------------------------------
# GENERAL CONFIGURATIONS
#------------------------------------------------------------------------------
module Requiem_ABS
#------------------------------------------------------------------------------
# Right hand attack key:
Right_Attack_Button = Input::Letters["A"]

# Left hand attack and Shield key:
Left_Attack_and_Shield_Button = Input::Letters["S"]

# Skills keys:
Skill_Buttons = [Input::Numberkeys[1], Input::Numberkeys[2], Input::Numberkeys[3]]

# Items keys:
Item_Buttons = [Input::Letters["Q"], Input::Letters["W"], Input::Letters["E"]]

# Text dysplayed when memorize skill or item in a hotkey
Memorize_Text = "Memorized!"

# Attack delay for player (in frames)
Hero_Attack_Time = 60

# Attack delay for enemies (in frames)
Enemy_Attack_Time = 90

# Divide the size of Animation by:
Animations_Divide_By = 3

# Use animations of the weapons? (true = yes / false = no)
Allow_Weapons_Graphics = true

# Use shields? (trus = sim / false = não)
Allow_Shields_Graphics = true

# Allow player to attack using shield in the same time? (true = yes / false = no)
Allow_attack_with_shield = false

# Use combo damage? (true = yes / false = no)
Combo_Damage = true

# Change 40 for animation ID
LevelUp_Animation = 40

# Recovery HP and MP when level-up? (true = yes / false = no)
Recovery_When_UpLevel = true

# Index of the Gold icon:
Gold_Drop_Graphic = 147

# Gold drop rate (in %)
Gold_Drop_Rate = 75

# Time to dropped item auto-erase (in frames):
Drop_Duration_Time = 450

# Show Reward items names? (true = yes / false = no)
Show_Reward = true

# Sound played when gold is dropped:
Drop_Money_SE = "DropMoney"

# Sound played when item is dropped:
Drop_Item_SE = "DropItem"

# Sound played when get item or gold:
Get_Reward_SE = "Getitem"

# Auto generate EXP and Gold Rate? (true = yes / false = no)
Auto_EXP_Gold_Rate = false

# Rate of EXP (in %) that enemy gives on die
EXP_Rate = 5

# Rate of Gold (in %) that enemy gives on die
Gold_Rate = 10

# Damage texts configurations:
Damage_Properties = []
Damage_Properties[1] = "Consolas" # Damage font
Damage_Properties[2] = 20 # Damage font size
Damage_Properties[3] = false # Font in bold? (true = yes / false = no)
Damage_Properties[4] = false # Font in italic? (true = yes / false = no)
Damage_Properties[5] = "Critical" # Critical damage text
Damage_Properties[6] = "Miss" # Miss damage text

Damage_Properties[7] = "Hits" # Hits text
Damage_Properties[8] = "Times New Roman" # Hits font
Damage_Properties[9] = 26 # Hits font size
Damage_Properties[10] = true # Font in bold? (true = yes / false = no)
Damage_Properties[11] = true # Font in italic? (true = yes / false = no)
Damage_Properties[12] = "Combo" # Combo damage text

Damage_Properties[13] = Color.new(255,255,255) # Damage font color
Damage_Properties[14] = Color.new(125,200,120) # Recovery font color
Damage_Properties[15] = Color.new(255,255,128) # Critical damage font color
Damage_Properties[16] = Color.new(245,150,120) # Combo damage font color
Damage_Properties[17] = Color.new(210,160,210) # Hits font color

Damage_Properties[18] = "Guard" # Defense text

Damage_Properties[19] = "Level Up" # Level-Up text
#------------------------------------------------------------------------------
end
#==============================================================================
#------------------------------------------------------------------------------
# Module RPG
#------------------------------------------------------------------------------
module RPG
  
  class State
    
    def animation_id
      self.note.each_line { |line|
      return line.gsub('Animation = ', '').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 duration
      self.note.each_line { |line|
      return line.gsub('Duration = ', '').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 = ', '').to_i if line.include?('Index = ')
      }
      return 0
    end
    
    def move_speed
      self.note.each_line { |line|
      return line.gsub('Speed = ', '').to_i if line.include?('Speed = ')
      }
      return 4
    end
    
    def range
      self.note.each_line { |line|
      return line.gsub('Range = ', '').to_i if line.include?('Range = ')
      }
      return 5
    end
    
    def delay
      self.note.each_line { |line|
      return line.gsub('Delay = ', '').to_i if line.include?('Delay = ')
      }
      return 60
    end
    
    def area
      self.note.each_line { |line|
      return line.gsub('Area = ', '').to_i if line.include?('Area = ')
      }
      return 3
    end
    
    def shot_se
      self.note.each_line { |line|
      return line.gsub('Shot SE = ', '').to_s if line.include?('Shot SE = ')
      }
      return nil
    end
    
    def combo_hits
      self.note.each_line { |line|
      return line.gsub('Combo Hits = ', '').to_i if line.include?('Combo Hits = ')
      }
      return 5
    end
    
    def combo_rate
      self.note.each_line { |line|
      return line.gsub('Combo Rate = ', '').to_i if line.include?('Combo Rate = ')
      }
      return 75
    end
    
    def ammo1
      self.note.each_line { |line|
      return $data_items[line.gsub('Ammo1 = ', '').to_i] if line.include?('Ammo1 = ')
      }
      return nil
    end
    
    def ammo2
      self.note.each_line { |line|
      return $data_items[line.gsub('Ammo2 = ', '').to_i] if line.include?('Ammo2 = ')
      }
      return nil
    end
    
    def defense_rate
      self.note.each_line { |line|
      return line.gsub('Defense Rate = ', '').to_i if line.include?('Defense Rate = ')
      }
      return 50
    end
    
  end
  
end

#------------------------------------------------------------------------------
# Game Battler
#------------------------------------------------------------------------------
class Game_Battler
  
  attr_accessor (:damage, :critical, :combo, :state_turns, :defending, :piece)
  
  alias requiem_abs_gbattler_execute_damage execute_damage
  alias requiem_abs_gbattler_make_obj_damage_value make_obj_damage_value
  
  def attack_effect(attacker)
    clear_action_results
    unless attack_effective?(attacker)
      @skipped = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    if rand(100) >= calc_hit(attacker)
      @missed = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    if rand(100) < calc_eva(attacker)
      @evaded = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    make_attack_damage_value(attacker)
    execute_damage(attacker)
    if @hp_damage == 0
      return
    end
    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[6]
      return
    end
    if rand(100) >= calc_hit(user, skill)
      @missed = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    if rand(100) < calc_eva(user, skill)
      @evaded = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    make_obj_damage_value(user, skill)
    make_obj_absorb_effect(user, skill)
    execute_damage(user)
    if skill.physical_attack and @hp_damage == 0
      return
    end
    apply_state_changes(skill)
  end
  
  def item_effect(user, item)
    clear_action_results
    unless item_effective?(user, item)
      @damage = Requiem_ABS::Damage_Properties[6]
      @skipped = true
      return
    end
    if rand(100) >= calc_hit(user, item)
      @missed = true
      @damage = Requiem_ABS::Damage_Properties[6]
      return
    end
    if rand(100) < calc_eva(user, item)
      @evaded = true
      @damage = Requiem_ABS::Damage_Properties[6]
      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)
    if item.physical_attack and @hp_damage == 0
      return
    end
    apply_state_changes(item)
  end
  
  def execute_damage(user)
    if @hp_damage == 0
      @damage = Requiem_ABS::Damage_Properties[6]
    elsif defending?(user)
      @damage = Requiem_ABS::Damage_Properties[18]
      return
    else
      @damage = @hp_damage
    end
    requiem_abs_gbattler_execute_damage(user)
  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
      @critical = (rand(100) < attacker.cri)
      @critical = false if prevent_critical
      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 calculate_combo(attacker)
    if attacker.is_a?(Game_Actor) and Requiem_ABS::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)
    else
      @combo = false
    end
  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.in_guard?(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.in_guard?(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, :item_hotkeys)
  
  alias requiem_abs_gactor_initialize initialize
  
  def initialize(actor_id)
    requiem_abs_gactor_initialize(actor_id)
    @skill_hotkeys = {}
    for s in Requiem_ABS::Skill_Buttons
      @skill_hotkeys[s] = 0
    end
    @item_hotkeys = {}
    for i in Requiem_ABS::Item_Buttons
      @item_hotkeys[i] = 0
    end
  end
  
  def display_level_up(new_skills)
    $game_system.battle_end_me.play
    $game_player.animation_id = Requiem_ABS::LevelUp_Animation
    @damage = Requiem_ABS::Damage_Properties[19]
    if Requiem_ABS::Recovery_When_UpLevel
      $game_player.actor.hp = $game_player.actor.maxhp
      $game_player.actor.mp = $game_player.actor.maxmp
    end
  end
  
  def atk_animation_id2
    if two_swords_style
      return weapons[1].nil? ? 1 : weapons[1].animation_id
    else
      return 1
    end
  end
  
end

#------------------------------------------------------------------------------
# Game Enemy
#------------------------------------------------------------------------------
class Game_Enemy < Game_Battler
  
  def atk_animation_id
    enemy.note.each_line { |line|
    return line.gsub('Attack Animation = ', '').to_i if line.include?('Attack Animation = ')
    }
    return 1
  end
  
  def die_animation_id
    enemy.note.each_line { |line|
    return line.gsub('Die Animation = ', '').to_i if line.include?('Die Animation = ')
    }
    return nil
  end
  
  def die_se
    enemy.note.each_line { |line|
    return line.gsub('Die SE = ', '').to_s if line.include?('Die SE = ')
    }
    return nil
  end
  
  def weapon_icon
    enemy.note.each_line { |line|
    return line.gsub('Weapon Icon = ', '').to_i if line.include?('Weapon Icon = ')
    }
    return 0
  end
  
  def shield_icon
    enemy.note.each_line { |line|
    return line.gsub('Shield Icon = ', '').to_i if line.include?('Shield Icon = ')
    }
    return 0
  end
  
  def defense_rate
    enemy.note.each_line { |line|
    return line.gsub('Defense Rate = ', '').to_i if line.include?('Defense Rate = ')
    }
    return 50
  end
  
end

#------------------------------------------------------------------------------
# Game Map
#------------------------------------------------------------------------------
class Game_Map
  
  def range_passable?(x, y, flag = 0x01)
    return true if @passages[@map.data[x, y, 0]] == 9
    passable?(x, y, flag)
  end
  
  def passable?(x, y, flag = 0x01)
    for drop in $game_drop
      next if drop.nil?
      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
  
  def in_range?(object)
    return false if object.real_x <= (@display_x-Graphics.width)
    return false if object.real_x >= (@display_x+(Graphics.width*9))
    return false if object.real_y <= (@display_y-Graphics.height)
    return false if object.real_y >= (@display_y+(Graphics.height*9))
    return true
  end
  
end

#------------------------------------------------------------------------------
# Game Character
#------------------------------------------------------------------------------
class Game_Character
  
  alias requiem_abs_gchar_initialize initialize
  alias requiem_abs_gchar_update update
  
  attr_accessor (:character_name, :character_index, :priority_type, :actor, :ani_time,
                 :state_time, :weapon1_attack_time, :weapon2_attack_time, :assigned_skill,
                 :skill_attack_time, :item_attack_time, :recovery_time, :right_attack_on,
                 :left_attack_on, :freeze, :anime_attack, :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 = 0
    @ani_time = 0
    @anime_attack = 0
    @state_time = 0
    @original_move_speed = 0
    @actor = nil
    @freeze = false
    @right_attack_on = false
    @left_attack_on = 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
    if self.is_a?(Game_Event) and self.in_battle or self.is_a?(Game_Player)
      for state in @actor.states
        next if state.nil?
        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 self.is_a?(Game_Event) 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
  end
  
  def in_range?(parent, target, range)
    x = (parent.x - target.x) * (parent.x - target.x)
    y = (parent.y - target.y) * (parent.y - target.y)
    r = x + y
    return true if r <= (range * range)
    return false
  end
  
  def in_direction?(parent, target)
    return true if parent.direction == 2 and target.y >= parent.y and target.x == parent.x
    return true if parent.direction == 4 and target.x <= parent.x and target.y == parent.y
    return true if parent.direction == 6 and target.x >= parent.x and target.y == parent.y
    return true if parent.direction == 8 and target.y <= parent.y and target.x == parent.x
    return false
  end
  
  def in_front?(parent, target)
    return true if parent.direction == 2 and parent.x == target.x and (parent.y+1) == target.y
    return true if parent.direction == 4 and (parent.x-1) == target.x and parent.y == target.y
    return true if parent.direction == 6 and (parent.x+1) == target.x and parent.y == target.y
    return true if parent.direction == 8 and parent.x == target.x and (parent.y-1) == target.y
    return false
  end
  
  def in_guard?(parent, target)
    return true if parent.direction == 2 and target.direction == 8
    return true if parent.direction == 4 and target.direction == 6
    return true if parent.direction == 6 and target.direction == 4
    return true if parent.direction == 8 and target.direction == 2
    return false
  end
  
  def move_toward(target)
    sx = distance_x_from(target)
    sy = distance_y_from(target)
    if sx != 0 or sy != 0
      if sx.abs > sy.abs
        sx > 0 ? move_left : move_right
        if @move_failed and sy != 0
          sy > 0 ? move_up : move_down
        end
      else
        sy > 0 ? move_up : move_down 
        if @move_failed and sx != 0
          sx > 0 ? move_left : move_right
        end
      end
    end
  end
  
  def turn_toward(target)
    sx = distance_x_from(target)
    sy = distance_y_from(target)
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    elsif sx.abs < sy.abs
      sy > 0 ? turn_up : turn_down
    end
  end
  
  def distance_x_from(target)
    sx = @x - target.x
    if $game_map.loop_horizontal?
      if sx.abs > $game_map.width / 2
        sx -= $game_map.width
      end
    end
    return sx
  end
  
  def distance_y_from(target)
    sy = @y - target.y
    if $game_map.loop_vertical?
      if sy.abs > $game_map.height / 2
        sy -= $game_map.height
      end
    end
    return sy
  end
  
end

#------------------------------------------------------------------------------
# Game Event
#------------------------------------------------------------------------------
class Game_Event < Game_Character
  
  attr_reader (:in_battle, :kill_with_weapon, :kill_with_skill, :kill_with_item,
               :respawn, :boss, :object, :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
    @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")
    @follow_distance = check_value("Follow")
    @erase = check_comment("Die Erase")
    @switch_local_a = check_comment("Die Self Switch A")
    @switch_local_b = check_comment("Die Self Switch B")
    @switch_local_c = check_comment("Die Self Switch C")
    @switch_local_d = check_comment("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_comment("Boss")
    @object = check_comment("Object")
    @puzzle = check_comment("Puzzle")
    if @enemy_id > 0 and !@in_battle
      @respawn = check_value("Respawn")
      @respawn = nil if @respawn <= 0
      self.actor = Game_Enemy.new(0, @enemy_id)
      self.actor.recover_all
      self.actor.piece = self
      @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? or $game_player.in_vehicle?
    for action in $data_enemies[@enemy_id].actions
      next unless self.actor.conditions_met?(action) or 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..6
          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
            end
          else
             skill_attack_normal
           end
        when 7..11
          skill_recover
        end
      end
    end
  end
  
  def attack_normal
    return unless in_front?(self, $game_player)
    return if $game_player.actor.nil?
    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 = Requiem_ABS::Enemy_Attack_Time
  end
  
  def skill_attack_normal
    return unless self.actor.mp >= self.assigned_skill.mp_cost and in_front?(self, $game_player)
    return if $game_player.actor.nil?
    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 = Requiem_ABS::Enemy_Attack_Time
  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_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 = Requiem_ABS::Enemy_Attack_Time
    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 = Requiem_ABS::Enemy_Attack_Time
        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
  end
  
  def dying
    if Requiem_ABS::Auto_EXP_Gold_Rate
      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::EXP_Rate / 100
      $game_player.actor.gain_exp(exp, 1)
    else
      $game_player.actor.gain_exp(self.actor.exp, 1)
    end
    make_drop
    unless @puzzle
      if self.actor.die_animation_id != nil
        @animation_id = self.actor.die_animation_id 
      end
      if self.actor.die_se != nil
        RPG::SE.new(self.actor.die_se).play
      else
        Sound.play_enemy_collapse
      end
    end
    @killed = true
  end
  
  def desactive_enemy
    if @erase
      erase
    elsif @switch_local_a
      key = [$game_map.map_id, self.id, "A"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @switch_local_b
      key = [$game_map.map_id, self.id, "B"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @switch_local_c
      key = [$game_map.map_id, self.id, "C"]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @switch_local_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
    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
      next if t.nil?
      $game_drop.push(Game_Drop.new(self, t.icon_index, t , 0))
    end
    if Requiem_ABS::Auto_EXP_Gold_Rate
      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::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_Graphic, nil, gold))
    end
  end
  
  def update_self_movement
    return if self.freeze or (self.anime_attack/2) > 0
    if @stop_count > 30 * (5 - @move_frequency)
      if @in_battle and in_range?(self, $game_player, @follow_distance)
        move_toward_player
      else
        case @move_type
        when 1
          move_type_random
        when 2
          move_type_toward_player
        when 3
          move_type_custom
        end
      end
    end
  end
  
  def check_value(comment)
    return 0 if @list.nil? or @list.size <= 0
    for item in @list
      if item.code == 108 or item.code == 408
        if item.parameters[0].downcase =~ /#{comment.downcase}[ ]?(\d+)?/
          return $1.to_i
        end
      end
    end
    return 0
  end
  
  def check_comment(comment)
    return false if @list.nil? or @list.size <= 0
    for item in @list
      if item.code == 108 or item.code == 408
        if item.parameters[0].downcase.include?(comment.downcase)
          return true
        end
      end
    end
    return false
  end
  
end

#------------------------------------------------------------------------------
# Game Player
#------------------------------------------------------------------------------
class Game_Player < Game_Character
  
  attr_accessor (:hit, :hits, :hit_time, :assigned_item, :bomb_already, :reward) 
  
  alias requiem_abs_gplayer_initialize initialize
  alias requiem_abs_gplayer_update update
  alias requiem_abs_gplayer_perform_transfer perform_transfer
  alias requiem_abs_gplayer_move_by_input move_by_input
  
  def initialize
    requiem_abs_gplayer_initialize
    @hits = 0
    @hit_time = 0
    @assigned_item = 0
    @bomb_already = false
    @hit = nil
    @reward = nil
    self.original_move_speed = 4
  end
  
  def update
    self.actor = $game_party.members[0]
    requiem_abs_gplayer_update
    return if self.actor.nil?
    self.actor.piece = self
    $game_temp.next_scene = "gameover" if self.actor.dead?
    return if $game_map.interpreter.running? or in_vehicle?
    attack_with_weapon
    attack_with_skill
    attack_with_item
    auto_recovery
    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 hit_count
    return unless Requiem_ABS::Combo_Damage
    @hits += 1
    @hit = "#{@hits}"
  end
  
  def attack_with_weapon
    if Input.trigger?(Requiem_ABS::Right_Attack_Button)
      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 = Requiem_ABS::Hero_Attack_Time
        @hit_time = self.weapon1_attack_time + 15
      end
    end
    if Input.press?(Requiem_ABS::Left_Attack_and_Shield_Button)
      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::Left_Attack_and_Shield_Button)
      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 = Requiem_ABS::Hero_Attack_Time
        @hit_time = self.weapon2_attack_time + 15
      elsif self.actor.two_swords_style
        normal_attack_left
        self.weapon2_attack_time = @attack_weapon_and_Shield.delay
        @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_exlpode_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...6
            item_normal_attack
          when 7...11
            item_recover
          end
        end
      end
    end
  end
  
  def normal_attack_right
    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 @attack_weapon != event.kill_with_weapon 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
    end
  end
  
  def range_attack_right
    return unless $game_party.has_item?(@attack_weapon.ammo1)
    $game_party.consume_item(@attack_weapon.ammo1)
    $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 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 @attack_weapon_and_Shield != event.kill_with_weapon 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
    end
  end
  
  def range_attack_left
    return unless $game_party.has_item?(@attack_weapon_and_Shield.ammo2)
    $game_party.consume_item(@attack_weapon_and_Shield.ammo2)
    $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 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
    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 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 = Requiem_ABS::Hero_Attack_Time
      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
    end
  end
  
  def skill_exlpode_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 = Requiem_ABS::Hero_Attack_Time
  end
  
  def item_normal_attack
    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 = Requiem_ABS::Hero_Attack_Time
      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
    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 = Requiem_ABS::Hero_Attack_Time
  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 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 = Requiem_ABS::Hero_Attack_Time
     return if 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
    end
  end
  
  def item_attack_bomb
    return if $game_party.has_item?(@assigned_item) and @bomb_already
    $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))
  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
      next if range.nil?
      range.destroy = true
    end
    for drop in $game_drop
      next if drop.nil?
      drop.destroy = true
    end
    for bomb in $game_bomb
      next if bomb.nil?
      bomb.destroy = true
    end
    @bomb_already = false
  end
  
  def move_by_input
    return if self.freeze or (self.anime_attack/2) > 0
    requiem_abs_gplayer_move_by_input
  end
  
end

#------------------------------------------------------------------------------
# Game Range
#------------------------------------------------------------------------------
class Game_Range < Game_Character
  
  attr_accessor (:draw, :destroy, :character_name)
  
  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
    moveto(@parent.x, @parent.y)
    @direction = @parent.direction
  end
  
  def update
    super
    return if @destroy
    @destroy = @step > @range
    return if moving?
    move_forward
    @step += 1
  end
  
  def check_event_trigger_touch(x, y)
    return if @destroy
    hurt_hero if $game_player.pos?(x, y) and @type == 3 and @parent.is_a?(Game_Event)
    for event in $game_map.events.values
      next unless event.in_battle and event.pos?(x, y) and @parent.is_a?(Game_Player)
      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
    @destroy = true
    $game_player.animation_id = @parent.assigned_skill.animation_id
    $game_player.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    $game_player.jump(0,0)
  end
  
  def hurt_enemy_weapon_right(enemy)
    @destroy = true
    return if enemy.actor.dead? or enemy.object
    enemy.animation_id = @parent.actor.equips[0].ammo1.animation_id if @parent.actor.equips[0].ammo1 != nil
    return if enemy.kill_with_weapon > 0 and @parent.actor.weapon_id != enemy.kill_with_weapon or 
    enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
    enemy.actor.attack_effect(@parent.actor)
    enemy.jump(0,0) unless enemy.puzzle
  end
  
  def hurt_enemy_weapon_left(enemy)
    @destroy = true
    return if enemy.actor.dead? or enemy.object
    if @parent.actor.two_swords_style
      @weapon = @parent.actor.equips[1]
    else
      @weapon = @parent.actor.equips[0]
    end
    enemy.animation_id = @weapon.ammo2.animation_id if @weapon.ammo2 != nil
    return if enemy.kill_with_weapon > 0 and @weapon.id != enemy.kill_with_weapon or 
    enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
    enemy.actor.attack_effect(@parent.actor)
    enemy.jump(0,0) unless enemy.puzzle
  end
  
  def hurt_enemy_skill(enemy)
    @destroy = true
    return if enemy.actor.dead? or enemy.object
    enemy.animation_id = @parent.assigned_skill.animation_id
    enemy.actor.skill_effect(@parent.actor, @parent.assigned_skill)
    enemy.jump(0,0) unless enemy.puzzle
  end
  
  def hurt_enemy_item(enemy)
    @destroy = true
    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 @parent.assigned_item != enemy.kill_with_item
    enemy.actor.item_effect(@parent.actor, @parent.assigned_item)
    enemy.jump(0,0) unless enemy.puzzle
  end
  
  def hurt_enemy_skill_explode
    @destroy = true
    for event in $game_map.events.values
      next unless event.in_battle
      next unless in_range?(self, event, @parent.assigned_skill.area)
      return if event.actor.dead? or event.object
      event.animation_id = @parent.assigned_skill.animation_id
      return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and @parent.assigned_skill != event.kill_with_skill
      event.actor.skill_effect(@parent.actor, @parent.assigned_skill)
      event.jump(0,0) unless event.puzzle
    end
  end
  
  def hurt_enemy_item_explode
    @destroy = true
    for event in $game_map.events.values
      next unless event.in_battle and in_range?(self, event, @parent.assigned_item.area)
      return if event.actor.dead? or event.object
      event.animation_id = @parent.assigned_item.animation_id
      return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
      event.kill_with_skill > 0 and @parent.assigned_item != event.kill_with_skill
      event.actor.item_effect(@parent.actor, @parent.assigned_item)
      event.jump(0,0) unless event.puzzle
    end
  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, :destroy, :graphic_name, :graphic_index)
  
  def initialize(parent, item)
    super()
    @parent = parent
    @item = item
    @graphic_name = "IconSet"
    @graphic_index = @item.icon_index
    @area = @item.area
    @time = @item.delay
    @destroy = false
    @draw = false
    self.priority_type = 2
    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_Item_SE).play if Requiem_ABS::Drop_Item_SE != ""
    $game_player.bomb_already = true
    jump(0,0)
    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 event in $game_map.events.values
      if event.in_battle and in_range?(self, event, @area)
        event.actor.item_effect(@parent.actor, @item)
        event.jump(0, 0) unless event.puzzle
      end
    end
    $game_player.bomb_already = false
    @destroy = true
  end
  
  def check_event_trigger_touch(x, y)
  end
  
end

#------------------------------------------------------------------------------
# Game Drop
#------------------------------------------------------------------------------
class Game_Drop < Game_Character
  
  attr_accessor (:draw, :destroy, :graphic_name, :graphic_index)
  
  def initialize(parent, graphic_index=0, item=nil, gold=0)
    super()
    @graphic_name = "IconSet"
    @graphic_index = graphic_index
    @item = item
    @gold = gold
    @drop_time = Requiem_ABS::Drop_Duration_Time
    moveto(parent.x, parent.y)
    RPG::SE.new(Requiem_ABS::Drop_Item_SE).play if Requiem_ABS::Drop_Item_SE != "" and @items != nil
    RPG::SE.new(Requiem_ABS::Drop_Money_SE).play if Requiem_ABS::Drop_Money_SE != "" and @gold > 0
    @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 = true if @drop_time <= 0
    return unless Input.trigger?(Input::C) and in_front?($game_player, self)
    get_reward
  end
  
  def get_reward
    RPG::SE.new(Requiem_ABS::Get_Reward_SE).play if Requiem_ABS::Get_Reward_SE != ""
    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_weapons[@item.id].name
    end
    if @gold > 0
      $game_party.gain_gold(@gold)
      $game_player.reward = "$ #{@gold}"
    end
    @destroy = true
  end
  
  def check_event_trigger_touch(x, y)
  end
  
end

#------------------------------------------------------------------------------
# Sprite Base
#------------------------------------------------------------------------------
class Sprite_Base
  
  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_By
        sprite.y = @animation_oy + cell_data[i, 2] / Requiem_ABS::Animations_Divide_By
        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_By
        sprite.y = @animation_oy + cell_data[i, 2] / Requiem_ABS::Animations_Divide_By
        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_By)
      sprite.zoom_y = cell_data[i, 3] / (100.0 * Requiem_ABS::Animations_Divide_By)
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end
  
end

#------------------------------------------------------------------------------
# Sprite Character
#------------------------------------------------------------------------------
class Sprite_Character < Sprite_Base
  
  alias requiem_abs_spchar_initialize initialize
  alias requiem_abs_spchar_update update
  alias requiem_abs_spchar_dispose dispose
  
  def initialize(viewport, character=nil)
    @character = character
    @_damage_duration = 0
    @_hit_duration = 0
    @_reward_duration = 0
    requiem_abs_spchar_initialize(viewport,@character)
  end
  
  def update
    requiem_abs_spchar_update
    update_show_dmg
    update_show_hit
    update_show_reward
    update_show_state_ani
  end
  
  def dispose
    requiem_abs_spchar_dispose
    dispose_damage
    dispose_hit
    dispose_reward
  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.damage = 0
      @character.actor.critical = @character.actor.combo = 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
      show_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)
    dispose_damage
    damage_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
    bitmap = Bitmap.new(160, 100)
    bitmap.font.name = Requiem_ABS::Damage_Properties[1]
    bitmap.font.size = Requiem_ABS::Damage_Properties[2]
    bitmap.font.bold = Requiem_ABS::Damage_Properties[3]
    bitmap.font.italic = Requiem_ABS::Damage_Properties[4]
    bitmap.font.color.set(0,0,0)
    bitmap.draw_text(1,(Requiem_ABS::Damage_Properties[2]*2)+5, 160, Requiem_ABS::Damage_Properties[2]+2, damage_string, 1)
    if value.is_a?(Numeric) and value <= 0
      bitmap.font.color = Requiem_ABS::Damage_Properties[14]
    else
      bitmap.font.color = Requiem_ABS::Damage_Properties[13]
    end
    bitmap.draw_text(0,(Requiem_ABS::Damage_Properties[2]*2)+4, 160, Requiem_ABS::Damage_Properties[2]+2, damage_string, 1)
    if critical
      bitmap.font.color.set(0,0,0)
      bitmap.draw_text(1, Requiem_ABS::Damage_Properties[2]+5, 160, Requiem_ABS::Damage_Properties[2]+2, Requiem_ABS::Damage_Properties[5], 1)
      bitmap.font.color = Requiem_ABS::Damage_Properties[15]
      bitmap.draw_text(0, Requiem_ABS::Damage_Properties[2]+4, 160, Requiem_ABS::Damage_Properties[2]+2, Requiem_ABS::Damage_Properties[5], 1)
    end
    if combo
      bitmap.font.color.set(0,0,0)
      bitmap.draw_text(1, 1, 160, Requiem_ABS::Damage_Properties[2]+2,Requiem_ABS::Damage_Properties[12], 1)
      bitmap.font.color = Requiem_ABS::Damage_Properties[16]
      bitmap.draw_text(0, 0, 160, Requiem_ABS::Damage_Properties[2]+2,Requiem_ABS::Damage_Properties[12], 1)
    end
    @_damage_sprite = ::Sprite.new(self.viewport)
    @_damage_sprite.bitmap = bitmap
    @_damage_sprite.ox = 80
    @_damage_sprite.oy = 20
    @_damage_sprite.x = self.x
    @_damage_sprite.y = self.y-self.oy/2-60
    @_damage_sprite.z = 99999
    @_damage_duration = 30
  end
  
  def hit(value)
    hit_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
    bitmap = Bitmap.new(160, Requiem_ABS::Damage_Properties[9])
    bitmap.font.name = Requiem_ABS::Damage_Properties[8]
    bitmap.font.size = Requiem_ABS::Damage_Properties[9]
    bitmap.font.bold = Requiem_ABS::Damage_Properties[10]
    bitmap.font.italic = Requiem_ABS::Damage_Properties[11]
    bitmap.font.color.set(0,0,0)
    bitmap.draw_text(1, 1, 160, 36,"#{hit_string}"+" "+"#{Requiem_ABS::Damage_Properties[7]}", 2)
    bitmap.font.color = Requiem_ABS::Damage_Properties[17]
    bitmap.draw_text(0, 0, 160, 36,"#{hit_string}"+" "+"#{Requiem_ABS::Damage_Properties[7]}", 2)
    @_hit_sprite = ::Sprite.new(self.viewport)
    @_hit_sprite.bitmap = bitmap
    @_hit_sprite.x = 374
    @_hit_sprite.y = 208 - Requiem_ABS::Damage_Properties[9]
    @_hit_sprite.z = 99999
    @_hit_duration = 60
  end
  
  def show_reward(reward)
    dispose_reward
    bitmap = Bitmap.new(200, 24)
    bitmap.font.size = 16
    bitmap.font.color = Color.new(0,0,0)
    bitmap.draw_text(1, 1, bitmap.width, 24, reward)
    bitmap.font.color = Color.new(255,255,255)
    bitmap.draw_text(0, 0, bitmap.width, 24, reward)
    @_reward_sprite = ::Sprite.new(self.viewport)
    @_reward_sprite.bitmap = bitmap
    @_reward_sprite.x = 10
    @_reward_sprite.y = 196
    @_reward_sprite.z = 99999
    @_reward_duration = 300
  end
  
  def dispose_damage
    if @_damage_sprite != nil
      @_damage_sprite.dispose
      @_damage_sprite = nil
    end
  end
  
  def dispose_hit
    if @_hit_sprite != nil
      @_hit_sprite.dispose
      @_hit_sprite = nil
    end
  end
  
  def dispose_reward
    if @_reward_sprite != nil
      @_reward_sprite.dispose
      @_reward_sprite = nil
    end
  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 @graphic_name == @character.graphic_name
    @graphic_name = @character.graphic_name
    self.bitmap = Cache.system(@graphic_name)
    self.ox = 12
    self.oy = 24
    sx = @character.graphic_index % 16 * 24
    sy = @character.graphic_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
    self.visible = @character.anime_attack > 0
    update_src_rect
    change_direction
  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 change_direction
    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?
    self.visible = @character.actor.defending
    update_src_rect
    change_direction
    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 change_direction
    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 !@character.actor.two_swords_style and @character.actor.armor1_id > 0
      return $data_armors[@character.actor.armor1_id].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
  
  attr_accessor :viewport3
  
  alias requiem_abs_sp_map_create_characters create_characters
  alias requiem_abs_sp_map_dispose_characters dispose_characters
  
  def create_characters
    @range_sprites = []
    for range in $game_range
      next if range.nil? or !$game_map.in_range?(range)
      @range_sprites.push(Sprite_Character.new(@viewport1, range))
    end
    @drop_sprites = []
    for drop in $game_drop
      next if drop.nil? or !$game_map.in_range?(drop)
      @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
    end
    for bomb in $game_bomb
      next if bomb.nil? or !$game_map.in_range?(bomb)
      @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
    end
    @weapon_sprites = []
    @weapon_sprites.push(Sprite_Weapon.new(@viewport1, $game_player))
    @shield_sprites = []
    @shield_sprites.push(Sprite_Shield.new(@viewport1, $game_player))
    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
    requiem_abs_sp_map_create_characters
  end
  
  def update_characters
    for sprite in @character_sprites
      if sprite.character.is_a?(Game_Event)
        if $game_map.in_range?(sprite.character) or sprite.character.trigger == 3 or sprite.character.trigger == 4       
          sprite.update
        end
      else
        sprite.update 
      end
    end
    for range in @range_sprites
      next if range.nil?  or !$game_map.in_range?(range.character)
      range.update
    end
    for drop in @drop_sprites
      next if drop.nil?  or !$game_map.in_range?(drop.character)
      drop.update
    end
    for weapon in @weapon_sprites
      next if weapon.nil?  or !$game_map.in_range?(weapon.character)
      weapon.update
    end
    for shield in @shield_sprites
      next if shield.nil?  or !$game_map.in_range?(shield.character)
      shield.update
    end
    for range in $game_range
      next if range.nil? or !$game_map.in_range?(range)
      unless range.draw
        @range_sprites.push(Sprite_Character.new(@viewport1, range))
        range.draw = true
      end
      if range.destroy
        $game_range.delete(range)
        range.character_name = ""
      end
    end
    for drop in $game_drop
      next if drop.nil? or !$game_map.in_range?(drop)
      unless drop.draw
        @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
        drop.draw = true
      end
      if drop.destroy
        $game_drop.delete(drop)
        drop.graphic_name = ""
      end
    end
    for bomb in $game_bomb
      next if bomb.nil? or !$game_map.in_range?(bomb)
      unless bomb.draw
        @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
        bomb.draw = true
      end
      if bomb.destroy
        $game_bomb.delete(bomb)
        bomb.graphic_name = ""
      end
    end
  end
  
  def dispose_characters
    requiem_abs_sp_map_dispose_characters
    for range in @range_sprites
      next if range.nil?
      range.dispose
    end
    for drop in @drop_sprites
      next if drop.nil?
      drop.dispose
    end
    for weapon in @weapon_sprites
      next if weapon.nil?
      weapon.dispose
    end
    for shield in @shield_sprites
      next if shield.nil?
      shield.dispose
    end
  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
  
  def create_game_objects
    requiem_abs_scenetitle_create_game_objects
    $game_range = []
    $game_drop = []
    $game_bomb = []
  end
  
end

#------------------------------------------------------------------------------
# Scene Map
#------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  
  alias requiem_abs_smap_update update
  alias requiem_abs_smap_terminate terminate
  
  def update
    requiem_abs_smap_update
    for range in $game_range
      next if range.nil? or !$game_map.in_range?(range)
      range.update
    end
    for drop in $game_drop
      next if drop.nil? or !$game_map.in_range?(drop)
      drop.update
    end
    for bomb in $game_bomb
      next if bomb.nil? or !$game_map.in_range?(bomb)
      bomb.update
    end
  end
  
  def update_encounter
  end
  
end

#------------------------------------------------------------------------------
# Scene Item
#------------------------------------------------------------------------------
class Window_Item < Window_Selectable
  
  def update_help
    if $scene.is_a?(Scene_Item) and $scene.message != nil
      @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 = nil
    @delay = 0
  end
  
  def update
    requiem_abs_sitem_update
    if @delay <= 0
      @message = nil
    else
      @delay -= 1
    end
  end
  
  def update_item_selection
    requiem_abs_sitem_update_item_selection
    for button in @actor.item_hotkeys.keys
      if Input.trigger?(button) and @item_window.item.is_a?(RPG::Item)
        Sound.play_decision
        @actor.item_hotkeys[button] = @item_window.item.id
        @message = Requiem_ABS::Memorize_Text
        @delay = 120
      end
    end
  end
  
end

#------------------------------------------------------------------------------
# Scene Skill
#------------------------------------------------------------------------------
class Window_Skill < Window_Selectable
  
  def update_help
    if $scene.is_a?(Scene_Skill) and $scene.message != nil
      @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 = nil
    @delay = 0
  end
  
  def update
    requiem_abs_sskill_update
    if @delay <= 0
      @message = nil
    else
      @delay -= 1
    end
  end
  
  def update_skill_selection
    requiem_abs_sskill_update_skill_selection
    for button in @actor.skill_hotkeys.keys
      if Input.trigger?(button)
        Sound.play_decision
        @actor.skill_hotkeys[button] = @skill_window.skill.id
        @message = "Memorizada!"
        @delay = 120
      end
    end
  end
  
end

#------------------------------------------------------------------------------
# Scene File
#------------------------------------------------------------------------------
class Scene_File < Scene_Base
 
  alias requiem_abs_sfile_write_save_data write_save_data
  alias requiem_abs_sfile_read_save_data read_save_data
  
  def write_save_data(file)
    requiem_abs_sfile_write_save_data(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_range         = Marshal.load(file)
    $game_drop          = Marshal.load(file)
    $game_bomb          = Marshal.load(file)
  end
 
end

#------------------------------------------------------------------------------
# High Priority
#------------------------------------------------------------------------------
Win32API.new("kernel32", "SetPriorityClass", "pi", "i").call(-1, 0x80)

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

Code:

#==============================================================================
# Requiem HUD
#==============================================================================

OnOff_Switch = 0 # Switch that show or hide the HUD

Skills_Text = "Skills" # Text displayed on skills window

Items_Text = "Items" # Text displayed on items window

Ammo_Text = "Ammo" # Text displayed on ammunitions window

#------------------------------------------------------------------------------
Requiem_Masterpiece.register("Requiem HUD", 1.0, "29/03/2009")
#------------------------------------------------------------------------------
if Requiem_Masterpiece.enabled?("Requiem ABS", 5.0)
#------------------------------------------------------------------------------
class Requiem_HUD1 < Window_Base
  
  def initialize
    super(-32, -32, 224, 140)
    self.opacity = 0
    @actor = $game_party.members[0]
    @old_hp = @actor.hp
    @old_mp = @actor.mp
    update
    refresh
  end
  
  def update
    return if $game_party.members.size <= 0
    return unless @old_hp != @actor.hp or @old_mp != @actor.mp or @actor != $game_party.members[0]
    @old_hp = @actor.hp
    @old_mp = @actor.mp
    @actor = $game_party.members[0]
    refresh
  end
  
  def refresh
    self.contents.clear
    draw_hpbar(@actor, 34, 16)
    draw_mpbar(@actor, 34, 38)
    self.contents.font.size = 16
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text(19, 15, 24, 24, Vocab::hp_a)
    self.contents.draw_text(19, 39, 24, 24, Vocab::mp_a)
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text(18, 14, 24, 24, Vocab::hp_a)
    self.contents.draw_text(18, 38, 24, 24, Vocab::mp_a)
  end
  
  def draw_hpbar(actor, x, y)
    base = Cache.system("Base")
    self.contents.blt(x, y, base, base.rect)
    bar = Cache.system("HP Bar")
    meter = Rect.new(0, 0, base.width * actor.hp / actor.maxhp, base.height)
    self.contents.blt(x, y, bar, meter)
  end  
  
  def draw_mpbar(actor, x, y)
    base = Cache.system("Base")
    self.contents.blt(x, y, base, base.rect)
    bar = Cache.system("MP Bar")
    meter = Rect.new(0, 0, base.width * actor.mp / actor.maxmp, base.height)
    self.contents.blt(x, y, bar, meter)
  end
  
end

#------------------------------------------------------------------------------
class Requiem_HUD2 < Window_Base
  
  def initialize
    super(-32,-32,608,480)
    self.opacity = 0
    @actor = $game_party.members[0]
    refresh
  end
  
  def update
    return if $game_party.members.size <= 0
    if @actor != $game_party.members[0]
      @actor = $game_party.members[0]
      refresh
    end
  end
  
  def refresh
    return if $game_party.members.size <= 0
    self.contents.clear
    self.contents.font.size = 16
    bitmap = Cache.system("HUD")
    rect = Rect.new(0, 0, 544, 416)
    self.contents.blt(16, 16, bitmap, rect)
    draw_skills(464, 28)
    draw_items(464, 396)
    draw_ammo(32, 396)
  end
  
  def draw_skills(x, y)
    skill_count = 0
    @actor.skill_hotkeys.each { |key, value|
    next if value.nil?
    skill = $data_skills[value]
    next if skill.nil?
    draw_icon(skill.icon_index, (32*skill_count)+x-4, y)
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text((32*skill_count)+x+5, y+17, 64, 24, Input.name?(key))
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text((32*skill_count)+x+4, y+16, 64, 24, Input.name?(key))
    skill_count += 1
    }
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text(x-7, y-15, 96, 24, Skills_Text, 1)
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text(x-8, y-16, 96, 24, Skills_Text, 1)
  end
  
  def draw_items(x, y)
    item_count = 0
    @actor.item_hotkeys.each { |key, value|
    next if value.nil?
    item = $data_items[value]
    next if item.nil?
    draw_icon(item.icon_index, (32*item_count)+x-4, y)
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text((32*item_count)+x+5, y+17, 64, 24, Input.name?(key))
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text((32*item_count)+x+4, y+16, 64, 24, Input.name?(key))
    item_count += 1
    }
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text(x-7, y-15, 96, 24, Items_Text, 1)
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text(x-8, y-16, 96, 24, Items_Text, 1)
  end
  
  def draw_ammo(x, y)
    if @actor.equips[0] != nil and @actor.equips[0].ranged?
      draw_icon(@actor.equips[0].ammo1.icon_index, x-4, y) if @actor.equips[0].ammo1 != nil
      draw_icon(@actor.equips[0].ammo2.icon_index, x+28, y) if @actor.equips[0].ammo2 != nil
      self.contents.font.color = Color.new(0,0,0)
      self.contents.draw_text(x+5, y+17, 32, 24, Input.name?(Requiem_ABS::Right_Attack_Button))
      self.contents.draw_text(x+37, y+17, 32, 24, Input.name?(Requiem_ABS::Left_Attack_and_Shield_Button))
      self.contents.font.color = Color.new(255,255,255)
      self.contents.draw_text(x+4, y+16, 32, 24, Input.name?(Requiem_ABS::Right_Attack_Button))
      self.contents.draw_text(x+36, y+16, 32, 24, Input.name?(Requiem_ABS::Left_Attack_and_Shield_Button))
    end
    self.contents.font.color = Color.new(0,0,0)
    self.contents.draw_text(x-7, y-16, 64, 24, Ammo_Text, 1)
    self.contents.font.color = Color.new(255,255,255)
    self.contents.draw_text(x-8, y-16, 64, 24, Ammo_Text, 1)
  end
  
end

#------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  
  alias requiem_hudstart start
  alias requiem_hudupdate update
  alias requiem_hudterminate terminate
  
  def start
    requiem_hudstart
    @hud_window1 = Requiem_HUD1.new
    @hud_window2 = Requiem_HUD2.new
    @hud_window1.visible = @hud_window1.active = false
    @hud_window2.visible = @hud_window2.active = false
    showing_hud
  end
  
  def update
    requiem_hudupdate
    @hud_window1.update if @hud_window1.active
    @hud_window2.update if @hud_window2.active
    showing_hud
  end
  
  def terminate
    requiem_hudterminate
    @hud_window1.dispose
    @hud_window2.dispose
  end
  
  def showing_hud
    if OnOff_Switch <= 0 or $game_switches[OnOff_Switch]
      @hud_window1.visible = @hud_window1.active = true
      @hud_window2.visible = @hud_window2.active = true
    else
      @hud_window1.visible = @hud_window1.active = false
      @hud_window2.visible = @hud_window2.active = false
    end
  end

end
#------------------------------------------------------------------------------
end

Code:

#==============================================================================
# Requiem Enemies HP Bars
#==============================================================================
#------------------------------------------------------------------------------
Requiem_Masterpiece.register("Requiem Enemy HP Bars", 1.0, "29/03/2009")
#------------------------------------------------------------------------------
if Requiem_Masterpiece.enabled?("Requiem ABS", 5.0)
#------------------------------------------------------------------------------
class Requiem_EnemyHPBars < Sprite
  
  def initialize(enemy, viewport)
    super(viewport)
    @enemy = enemy
    @old_x = @old_y = 0
    self.bitmap = Bitmap.new(45, 8)
    refresh
  end
  
  def update
    super
    return unless @old_x != @enemy.screen_x-(self.bitmap.width/2) or @old_y != @enemy.screen_y
    @old_x = self.x = @enemy.screen_x-(self.bitmap.width/2)
    @old_y = self.y = @enemy.screen_y
    refresh
  end
  
  def refresh
    self.bitmap.clear
    meter = (self.bitmap.width-2) * @enemy.actor.hp / @enemy.actor.maxhp
    self.bitmap.fill_rect(0, 0, self.bitmap.width, self.bitmap.height, Color.new(0,0,0))
    self.bitmap.gradient_fill_rect(1, 2, meter, (self.bitmap.height-4)/2, Color.new(255,160,160), Color.new(224,0,0))
    self.bitmap.gradient_fill_rect(1, 2+((self.bitmap.height-4)/2), meter, (self.bitmap.height-4)/2, Color.new(224,64,64), Color.new(96,0,0))
  end
  
  def dispsoe
    super
    self.bitmap.dispose
    self.dispose
  end
  
end

#------------------------------------------------------------------------------
class Requiem_BossBar < Sprite
  
  def initialize(event, viewport)
    super(viewport)
    @enemy = event
    @hp = @enemy.actor.hp
    @base = Cache.system("Boss Base")
    @bar = Cache.system("Boss Bar")
    self.bitmap = Bitmap.new(@base.width, @base.height)
    self.x = (544 - self.bitmap.width) / 2
    self.y = 416 - self.bitmap.height - 64
    refresh
  end
  
  def update
    super
    return if @hp == @enemy.actor.hp
    @hp = @enemy.actor.hp
    refresh
  end
  
  def refresh
    self.bitmap.clear
    self.bitmap.blt(0, 0, @base, @base.rect)
    meter = Rect.new(0, 0, @base.width * @enemy.actor.hp / @enemy.actor.maxhp, @base.height)
    self.bitmap.blt(0, 0, @bar, meter)
  end
  
  def dispsoe
    super
    self.bitmap.dispose
    @bitmap2.dispose
    self.dispose
  end
  
end

#------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  
  alias requiem_abs_enemyhp_smap_start start
  alias requiem_abs_enemyhp_smap_update update
  alias requiem_abs_enemyhp_smap_terminate terminate
  alias requiem_abs_enemyhp_smap_update_transfer_player update_transfer_player
  
  def start
    @enemies_hp_bars = {}
    requiem_abs_enemyhp_smap_start
  end
  
  def update
    requiem_abs_enemyhp_smap_update
    update_enemies_hp_bars
  end
  
  def update_enemies_hp_bars
    for event in $game_map.events.values
      next unless event.in_battle
      if event.boss
        if @boss_hud.nil? and !event.actor.dead?
          @boss_hud = Requiem_BossBar.new(event, @spriteset.viewport3) 
        elsif @boss_hud != nil and !event.actor.dead?
          @boss_hud.update
        elsif @boss_hud != nil and event.actor.dead?
          @boss_hud.dispose 
          @boss_hud = nil
        end
      else
        if $game_player.in_range?($game_player, event, 3) and @enemies_hp_bars[event.id].nil? and !event.actor.dead?
          next if event.object or event.puzzle
          @enemies_hp_bars[event.id] = Requiem_EnemyHPBars.new(event, @spriteset.viewport3)
        elsif $game_player.in_range?($game_player, event, 3) and @enemies_hp_bars[event.id] != nil and !event.actor.dead?
          @enemies_hp_bars[event.id].update
        elsif @enemies_hp_bars[event.id] != nil
          @enemies_hp_bars[event.id].dispose
          @enemies_hp_bars[event.id] = nil
        end
      end
    end
  end
  
  def terminate
    requiem_abs_enemyhp_smap_terminate
    dispose_bars
  end
  
  def update_transfer_player
    dispose_bars if $game_player.transfer?
    requiem_abs_enemyhp_smap_update_transfer_player
  end
  
  def dispose_bars
    if @boss_hud != nil
      @boss_hud.dispose
      @boss_hud = nil
    end
    for i in @enemies_hp_bars.values
      next if i.nil?
      i.dispose
    end
    @enemies_hp_bars.clear
  end
  
end
#------------------------------------------------------------------------------
end