VX to XP

Ich habe ein Script gefunden, welches ich verwenden will.
Aber das problem ist, dass es ein VX Script ist.
Wie kann ich das Script für den XP verwenden?
Ich habe mal von einem "Konverter" gehört, aber mehr weiß ich auch nicht.
Kennt sich da einer aus bzw. kann mir wer helfen?
MfG Deamonic

Von einem Konverter habe ich nichts gehört, bezweifle das es diesen auch gibt, denn der VX ist anders aufgebaut als der XP. Was für ein Script ist es denn? Vielleicht gibt es ja ein ähliches für den XP...

Es ist ein Kampfsystem.
Ich werd mich mal unter rpg-studio erkundigen. Dort gibt es ja viele Scripter ...

Automatisch konvertieren geht nicht. Das muss man schon manuell machen. Aber bei einem Kampfsystem könnte das ggf. recht viel Arbeit sein. Du kannst ja das KS-Script mal posten (bitte im Code-Tag!).

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

---

Wenn Ich mich nicht irre, dann ist das so ein KS wie von Tankentai oder? Oder doch so eins wie von Moghunter?

Screen Tankentai:
http://rpg-studio.de/itzamna/sites/d.../files/ss3.jpg

Screen Moghunter:
http://www.atelier-rgss.com/RGSS/Battle/XAS_SC01.png
(Ich liebe dieses KS xD)

Es ist Action Kampfsystem von Vlad einem Portugiesen (oder Franzosen).
Es ist eins vie von Moghunter, aber viel einfacher.
Mir gefällt dieses besser, das XAS ist serh schwer zum verstehen.
Ich glaube Hybris 2nd Awakening verwendet das XAS.

Ich bin ja weder Ruby-Fan noch -Experte ich würde es lieber
vom Maker abschaffen aber tut ja nix zur Sache. Es gibt auch
Scripte die sich sogar mit beiden Versionen vertragen können,
da sie getrennten Code für beide haben aber sie beide im
selben Script stehen (siehe Apt Ploutôn Database).

Zitat:

---

Wie kann ich das Script für den XP verwenden?
Ich habe mal von einem "Konverter" gehört, aber mehr weiß ich auch nicht.

---

Also wenns einen Converter gibt dann muss der aber seeehr komplex
arbeiten was das Code-Umgeschreibe angeht xD ~ und es würden
garantiert einige Scripte sich nicht convertieren lassen weil sie zur
Zielversion kein Stück passen.

Ich habe jetzt nachgeforscht und herausgefunden, dass der benannte Converter nicht für die Scripts, sondern für Grafiken da ist.
War mein Fehler.