#==============================================================================
# Vampyr - Verus Tempus Proelium
#==============================================================================
Vampyr_Kernel.register("Vampyr Verus Tempus Proelium", 1.0, "03/23/2010")
#------------------------------------------------------------------------------
# Key to attack
Attack_Key = Input::X

# Key to use shield
Defend_Key = Input::Y

# Key used to cast skills (R = Letter W)
Skills_Key = Input::R

# Key used to cast items ( L = Letter Q)
Items_Key  = Input::L

# Key used to change allies actions (Z = Letter D)
Allies_Key = Input::Z

# Index of the gold icon and drop %
Gold_Properties = 147, 50

# Battle Area Variable (Used to open doors after kill X enemies, for example)
Battle_Area_Variable = 0

# Hits Propertires
Hit = {}
Hit["show"]     = true
Hit["font"]     = ["Georgia", 22, false, true] # Face, Size, Bold, Italic
Hit["texts"]    = ["Hits", "Total Damage"]
Hit["position"] = [334, 175]

# Damage Properties
Damage = {}
Damage["font"]  = ["Georgia", 20, false, true] # Face, Size, Bold, Italic
Damage["texts"] = ["Miss", "Critical", "Guard"]

#------------------------------------------------------------------------------
class VerusTempusProelium
  
  attr_reader :attack_key
  attr_reader :defend_key
  attr_reader :skills_key
  attr_reader :items_key
  attr_reader :allies_key
  attr_reader :hit
  attr_reader :damage
  attr_reader :hits_total
  attr_reader :damage_total
  attr_reader :gold_properties
  attr_reader :battle_area_variable
  
  def initialize
    @hits_total = 0
    @damage_total = 0
    @hitcount_delay = 0
    @attack_key = Attack_Key
    @defend_key = Defend_Key
    @skills_key = Skills_Key    
    @items_key = Items_Key
    @allies_key = Allies_Key
    @hit = Hit
    @damage = Damage
    @gold_properties = Gold_Properties
    @battle_area_variable = Battle_Area_Variable
  end
  
  def update
    if @hitcount_delay > 0
      @hitcount_delay -= 1
    elsif @hitcount_delay <= 0 and @hits_total > 0
      @hits_total = 0
      @damage_total = 0
    end
  end
  
  def melee_attack(attacker, target)
    attacker.attack_delay = attacker.actor.attack_speed
    attacker.animation_delay = 30
    return unless valid_target?(target)
    return if guard?(attacker, target)
    target.actor.attack_effect(attacker.actor)
    target.animation_id = attacker.actor.atk_animation_id.to_i
    hit_count(attacker, target)
    target.target = attacker unless same_team?(attacker, target)
  end
  
  def melee_attack2(attacker, target)
    attacker.attack2_delay = attacker.actor.attack_speed
    attacker.animation_delay = 30
    return unless valid_target?(target)
    return unless attacker.in_front?(target)
    return if guard?(attacker, target)
    target.actor.attack_effect(attacker.actor)
    target.animation_id = attacker.actor.atk_animation_id2
    hit_count(attacker, target)
    target.target = attacker unless same_team?(attacker, target)
  end
  
  def range_attack(attacker, hand)
    weapon = attacker.actor.weapons[hand]
    return if weapon.ammo_list.empty?
    return if attacker.actor.ammos[weapon.id] == nil
    ammo = $data_items[attacker.actor.ammos[weapon.id]]
    return if ammo == nil
    return unless $game_party.has_item?(ammo)
    $game_party.consume_item(ammo)
    attacker.attack_delay = [(60-ammo.speed), 10].max if hand == 0
    attacker.attack2_delay = [(60-ammo.speed), 10].max if hand == 1
    attacker.animation_delay = 30
    $game_projectiles << Game_Projectile.new(attacker, ammo)
  end
  
  def skill_attack(attacker, skill, parent=nil)
    return if attacker.actor.mp < skill.mp_cost
    attacker = (parent == nil ? attacker : parent)
    target = (attacker.heal_target == nil ? select_target(attacker, skill) :  attacker.heal_target)
    if !target.empty? and parent == nil
      attacker.actor.mp -= attacker.actor.calc_mp_cost(skill)
      $game_temp.common_event_id = skill.common_event_id if skill.common_event_id > 0
      attacker.skill_delay = [(60-skill.speed), 10].max
      attacker.animation_delay = 30
    end
    for i in target.compact
      next if guard?(attacker, i)
      i.actor.skill_effect(attacker.actor, skill)
      i.animation_id = skill.animation_id
      hit_count(attacker, i)
      i.target = attacker.actor.character unless same_team?(attacker, i)
    end
  end
  
  def cast_skill(attacker, skill)
    return if attacker.actor.mp < skill.mp_cost
    attacker.actor.mp -= attacker.actor.calc_mp_cost(skill)
    $game_temp.common_event_id = skill.common_event_id if skill.common_event_id > 0
    attacker.skill_delay = [(60-skill.speed), 10].max
    attacker.animation_delay = 30
    $game_projectiles << Game_Projectile.new(attacker, skill)
  end
  
  def item_attack(attacker, item, parent=nil)
    attacker = (parent == nil ? attacker : parent)
    return unless $game_party.has_item?(item)
    target = (attacker.heal_target == nil ? select_target(attacker, item) :  attacker.heal_target)
    if !target.empty? and parent == nil
      $game_party.consume_item(item)
      $game_temp.common_event_id = item.common_event_id if item.common_event_id > 0
      attacker.item_delay = [(60-item.speed), 10].max
      attacker.animation_delay = 30
    end
    for i in target.compact
      next if guard?(attacker, i)
      i.actor.item_effect(attacker.actor, item)
      i.animation_id = item.animation_id
      hit_count(attacker, i)
      i.target = attacker.actor.character unless same_team?(attacker, i)
    end
  end
  
  def cast_item(attacker, item)
    return unless $game_party.has_item?(item)
    $game_party.consume_item(item)
    $game_temp.common_event_id = item.common_event_id if item.common_event_id > 0
    attacker.item_delay = [(60-item.speed), 10].max
    attacker.animation_delay = 30
    $game_projectiles << Game_Projectile.new(attacker, item)
  end
  
  def select_target(attacker, object=nil)
    targets = []
    targets << $game_player if $game_player.actor != nil
    for ally in $game_allies.compact
      next unless $game_map.in_range?(ally)
      next if ally.actor.dead?
      targets << ally
    end
    for monster in $game_monsters.compact
      next unless $game_map.in_range?(monster)
      next if monster.actor.dead?
      targets << monster
    end
    for event in $game_map.events.values.compact
      next unless $game_map.in_range?(event)
      next if event.actor == nil
      next if event.actor.dead?
      targets << event
    end
    return targets if object == nil
    case object.scope
    when 1
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target if attacker.in_front?(target)
      end
      return selected
    when 2
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target
      end
      return selected
    when 3
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target if attacker.in_front?(target)
      end
      return selected
    when 4
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target if attacker.in_front?(target)
      end
      return selected[rand(selected.size)]
    when 5
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target if attacker.in_front?(target)
      end
      return selected
      a = selected[rand(selected.size)]
      b = targets - a
      c = b[rand(b.size)]
      return [a, c]
    when 6
      selected = []
      for target in targets
        next if same_team?(attacker, target)
        selected << target if attacker.in_front?(target)
      end
      return selected
      a = selected[rand(selected.size)]
      b = targets - a
      c = b[rand(b.size)]
      d = b - c
      e = d[rand(d.size)]
      return [a, c, e]
    when 7
      selected = []
      for target in targets
        next unless same_team?(attacker, target)
        selected << target
      end
      return [selected[rand(selected.size)]]
    when 8
      selected = []
      for target in targets
        next unless same_team?(attacker, target)
        selected << target
      end
      return selected
    when 9
      selected = []
      targets = []
      for ally in $game_allies.compact
        next unless $game_map.in_range?(ally)
        targets << ally if ally.actor.dead?
      end
      for monster in $game_monsters.compact
        next unless $game_map.in_range?(monster)
        targets << monster if monster.actor.dead?
      end
      for event in $game_map.events.values.compact
        next unless $game_map.in_range?(event)
        next if event.is_object?
        next if event.actor == nil
        next if event.actor.dead?
        targets << event if event.actor.dead?
      end
      for target in targets
        next unless same_team?(attacker, target)
        selected << target
      end
      return [selected[rand(selected.size)]]
    when 10
      selected = []
      targets = []
      for ally in $game_allies.compact
        next unless $game_map.in_range?(ally)
        targets << ally if ally.actor.dead?
      end
      for monster in $game_monsters.compact
        next unless $game_map.in_range?(monster)
        targets << monster if monster.actor.dead?
      end
      for event in $game_map.events.values.compact
        next unless $game_map.in_range?(event)
        next if event.is_object?
        next if event.actor == nil
        next if event.actor.dead?
        targets << event if event.actor.dead?
      end
      for target in targets
        next unless same_team?(attacker, target)
        selected << target
      end
      return selected
    when 11
      return [attacker]
    end
    return []
  end
  
  def enemy_actions(attacker)
    return if attacker.actor == nil
    return if attacker.actor.dead?
    for action in attacker.actor.enemy.actions
      next unless attacker.actor.conditions_met?(action)
      next if rand(11) > action.rating and (!action.kind == 1 and action.rating >= 10)
      case action.kind
      when 0
        case action.basic
        when 0
          next if blocked_by_state?(attacker, 0)
          next if attacker.attack_delay > 0
          for target in select_target(attacker)
            next if same_team?(attacker, target)
            next unless attacker.in_front?(target)
            attacker.target = target
            melee_attack(attacker, target)
          end
        when 1
          attacker.defend_delay = attacker.actor.attack_speed
        end
      when 1
        next if blocked_by_state?(attacker, 1)
        skill = $data_skills[action.skill_id]
        next if attacker.skill_delay > 0
        if skill.scope >= 7
          targets = []
          for monster in $game_monsters.compact
            next unless $game_map.in_range?(monster)
            next if monster.actor.dead?
            targets << monster
          end
          for event in $game_map.events.values.compact
            next unless $game_map.in_range?(event)
            next if event.erased
            next if event.actor == nil
            next if event.is_object?
            targets << event
          end
          for target in targets.compact
            next unless curable?(target, skill)
            attacker.heal_target = [target]
            skill_attack(attacker, skill)
          end
        else
          if skill.ranged?
            if action.rating >= 10
              cast_skill(attacker, skill)
            else
              for target in select_target(attacker, skill)
                next if same_team?(self, target)
                next unless attacker.in_range?(target, skill.range)
                next unless attacker.in_direction?(target)
                attacker.target = target
                cast_skill(attacker, skill)
              end
            end
          else
            skill_attack(attacker, skill)
          end
        end
      end  
    end
  end
  
  def make_drop(attacker)
    Sound.play_enemy_collapse
    for ally in $game_allies.compact
      ally.target = nil if ally.target == attacker
    end
    droped_items = []
    for i in [attacker.actor.drop_item1, attacker.actor.drop_item2]
      next if i.kind <= 0
      next if rand(i.denominator) != 0
      case i.kind
        when 1; droped_items << $data_items[i.item_id]
        when 2; droped_items << $data_weapons[i.weapon_id]
        when 3; droped_items << $data_armors[i.armor_id]
      end
    end
    for actors in $game_party.members
      actors.gain_exp(attacker.actor.exp, true)
    end
    if rand(100) < @gold_properties[1] and attacker.actor.gold > 0
      $game_items << Game_Item.new(attacker, attacker.actor.gold)
    end
    droped_items.compact.each { |i| $game_items << Game_Item.new(attacker, i) }
    if $game_system.enemies_defeated[attacker.target.actor.id][attacker.actor.enemy_id] == nil
      $game_system.enemies_defeated[attacker.target.actor.id][attacker.actor.enemy_id] = 1
    else
      $game_system.enemies_defeated[attacker.target.actor.id][attacker.actor.enemy_id] += 1
    end
    $game_variables[@battle_area_variable] += 1 if @battle_area_variable > 0
    
  end
  
  def hit_count(attacker, target)
    return unless @hit["show"]
    return unless attacker.is_a?(Game_Player)
    return if target.is_a?(Game_Player)
    return if target.is_object?
    @hits_total += 1
    @damage_total += target.damage.to_i
    @hitcount_delay = 60
  end
  
  def valid_target?(target)
    return false if target == nil
    return false if target.actor == nil
    return false if target.actor.dead?
    return false if target.in_vehicle?
    return true if target.is_a?(Game_Player)
    return true if target.is_a?(Game_Ally)
    return true if target.is_a?(Game_Monster)
    return true if target.is_a?(Game_Event) and target.actor != nil
    return false
  end
  
  def guard?(attacker, target)
    return false if target == nil
    return false unless target.defending
    return false unless attacker.face_to_face?(target)
    if target.actor.is_a?(Game_Actor)
      return false unless target.actor.armors[0].is_a?(RPG::Armor)
      rate = target.actor.armors[0].guard_rate.to_i
    elsif target.actor.is_a?(Game_Enemy)
      rate = target.actor.guard_rate.to_i
    end
    if rand(101) <= rate
      target.damage = "Guard"
      return true
    end
    return false
  end
  
  def same_team?(attacker, target)
    if attacker.is_a?(Game_Ally) or attacker.is_a?(Game_Player)
      return true if target.is_a?(Game_Ally) or target.is_a?(Game_Player)
    end
    if attacker.is_a?(Game_Monster) or (attacker.is_a?(Game_Event) and attacker.actor != nil)
      return true if target.is_a?(Game_Monster) or (target.is_a?(Game_Event) and target.actor != nil)
    end
    if attacker.is_a?(Game_Projectile)
      if (attacker.parent.is_a?(Game_Ally) or attacker.parent.is_a?(Game_Player)) and
        (target.is_a?(Game_Ally) or target.is_a?(Game_Player))
        return true
      end
      if (attacker.parent.is_a?(Game_Monster) or (attacker.is_a?(Game_Event) and attacker.actor != nil)) and
        (target.is_a?(Game_Monster) or (target.is_a?(Game_Event) and target.actor != nil))
        return true
      end
    end
    return false
  end
  
  def curable?(target, object)
    return false if object.scope < 7
    for state in target.actor.states.compact
      return true if object.minus_state_set.include?(state.id)
    end
    return false if target.actor.dead?
    if (target.actor.hp < (target.actor.maxhp*25/100)) and
      ((object.is_a?(RPG::Skill) and object.base_damage < 0) or
      (object.is_a?(RPG::Item) and (object.hp_recovery_rate > 0 or object.hp_recovery > 0)))
      return true
    end
    if (object.is_a?(RPG::Item) and target.actor.mp < (target.actor.maxmp*25/100)) and
      (object.mp_recovery_rate > 0 or object.mp_recovery > 0)
      return true
    end
    return false
  end
  
  def blocked_by_state?(attacker, kind)
    return if attacker.actor == nil
    for state in attacker.actor.states.compact
      return true if kind == 0 and state.restriction == 4
      return true if kind == 1 and state.restriction == 1
      return true if kind == 2 and state.restriction == 5
    end
    return false
  end
  
end

#------------------------------------------------------------------------------
module RPG
  
  class State
    
    def animation_id
      self.note.read("Animation")
    end
    
  end
  
  class BaseItem
    
    def ranged?
      self.note.load("Ranged")
    end
    
    def character
      self.note.read("Character")
    end
    
    def index
      self.note.read("Index")
    end
    
    def move_speed
      self.note.read("Speed", 6)
    end
    
    def range
      self.note.read("Range", 5)
    end
    
    def guard_rate
      self.note.read("Guard Rate", 50)
    end
    
    def ammo?
      self.note.load("Ammo")
    end
    
    def ammo_list
      ammos = self.note.read("Ammos")
      return [] if ammos == nil
      list = []
      for i in ammos.split(",")
        list << i.to_i
      end
      return list
    end
    
  end
  
end

#------------------------------------------------------------------------------
class Object
  
  def load(param)
    self.each_line { |i| return true if i =~ /#{param}/i }
    return false
  end
  
  def read(param, onfail=nil)    
    self.each_line { |i| return i.gsub("#{param} = ", "").chomp if i =~ /#{param} = /i }
    return onfail
  end
  
end

#------------------------------------------------------------------------------
class Bitmap
  
  def draw_outlined_text(*args)
    if args[0].is_a?(Rect)
      x = args[0].x
      y = args[0].y
      w = args[0].width
      h = args[0].height
      s = args[1]
      a = (args[2].nil? ? 0 : args[2])
    else
      x = args[0]
      y = args[1]
      w = args[2]
      h = args[3]
      s = args[4]
      a = (args[5].nil? ? 0 : args[5])
    end
    color = font.color.clone
    font.shadow = false
    font.color = Color.new(0,0,0)
    draw_text(x-1, y-1, w, h, s, a)
    draw_text(x+1, y-1, w, h, s, a)
    draw_text(x-1, y+1, w, h, s, a)
    draw_text(x+1, y+1, w, h, s, a)
    font.color = color.clone
    draw_text(x, y, w, h, s, a)
  end
  
end

#------------------------------------------------------------------------------
class Game_System
  
  attr_accessor :enemies_defeated
  
  alias vtp_gsystem_initialize initialize
  
  def initialize
    vtp_gsystem_initialize
    @enemies_defeated = {}
  end
  
end

#------------------------------------------------------------------------------
class Game_Battler
  
  attr_accessor :character
  
  alias vtp_gbattler_execute_damage execute_damage
  
  def attack_effect(attacker)
    clear_action_results
    return if @character.unkileable?
    if @character.is_object?
      self.hp -= self.maxhp
      return
    end
    unless attack_effective?(attacker)
      @character.damage = $VTP.damage["texts"][0]
      @skipped = true
      return
    end
    if rand(100) >= calc_hit(attacker)
      @character.damage = $VTP.damage["texts"][0]
      @missed = true
      return
    end
    if rand(100) < calc_eva(attacker)
      @character.damage = $VTP.damage["texts"][0]
      @evaded = true
      return
    end
    make_attack_damage_value(attacker)
    execute_damage(attacker)
    if @hp_damage == 0
      @character.damage = $VTP.damage["texts"][0]
      return                                    
    end
    apply_state_changes(attacker)
  end
  
  def skill_effect(user, skill)
    clear_action_results
    return if @character.unkileable?
    if @character.is_object?
      self.hp -= self.maxhp
      return
    end
    unless skill_effective?(user, skill)
      @character.damage = $VTP.damage["texts"][0]
      @skipped = true
      return
    end
    if rand(100) >= calc_hit(user, skill)
      @character.damage = $VTP.damage["texts"][0]
      @missed = true
      return
    end
    if rand(100) < calc_eva(user, skill)
      @character.damage = $VTP.damage["texts"][0]
      @evaded = true
      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
    return if @character.unkileable?
    if @character.is_object?
      self.hp -= self.maxhp
      return
    end
    unless item_effective?(user, item)
      @character.damage = $VTP.damage["texts"][0]
      @skipped = true
      return
    end
    if rand(100) >= calc_hit(user, item)
      @character.damage = $VTP.damage["texts"][0]
      @missed = true
      return
    end
    if rand(100) < calc_eva(user, item)
      @character.damage = $VTP.damage["texts"][0]
      @evaded = true
      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)
    vtp_gbattler_execute_damage(user)
    @character.damage = @hp_damage
    @character.critical = @critical
  end
  
  def remove_state(state_id)
    return unless state?(state_id)
    @states.delete(state_id)
    @state_turns.delete(state_id)
  end
  
end
#------------------------------------------------------------------------------
class Game_Party < Game_Unit
  
  attr_accessor :reward
  
  alias vtp_gparty_setup_starting_members setup_starting_members
  alias vtp_gparty_add_actor add_actor
  alias vtp_gparty_remove_actor remove_actor
  alias vtp_gparty_gain_item gain_item
  alias vtp_gparty_gain_gold gain_gold
  
  def setup_starting_members
    vtp_gparty_setup_starting_members
    for i in 1...@actors.size
      next if @actors[i] == nil
      $game_allies[i] = Game_Ally.new(i)
    end
    for i in members
      $game_system.enemies_defeated[i.id] = {}
    end
  end
  
  def add_actor(actor_id)
    vtp_gparty_add_actor(actor_id)
    id = @actors.size-1
    if @actors.size > 1
      $game_allies[id] = Game_Ally.new(id)
      $game_allies[id].moveto($game_player.x, $game_player.y)
      $game_allies[id].move_random
      $game_player.refresh
      $scene.refresh_allies_sprites if $scene.is_a?(Scene_Map)
    end
    if $game_system.enemies_defeated[actor_id] == nil
      $game_system.enemies_defeated[actor_id] = {}
    end
  end
  
  def remove_actor(actor_id)
    vtp_gparty_remove_actor(actor_id)
    for ally in $game_allies.compact
      next if ally.actor.id != actor_id
      $game_allies.delete(ally)
      $game_player.refresh
      $scene.refresh_allies_sprites if $scene.is_a?(Scene_Map)
    end
  end
  
  def gain_item(item, n, include_equip = false)
    vtp_gparty_gain_item(item, n, include_equip)
    @reward = item.name if n > 0 and item != nil and $scene.is_a?(Scene_Map)
  end
  
  def gain_gold(n)
    vtp_gparty_gain_gold(n)
    @reward = "#{Vocab.gold} #{n}" if n > 0 and $scene.is_a?(Scene_Map)
  end
  
  def change_group_order
    availables = []
    unavailables = []
    for actor in members
      if actor.dead?
        unavailables << actor
      else
        availables << actor
      end
    end
    return if availables.empty?
    availables.reverse!
    @actors.clear
    for i in availables
      add_actor(i.id)
    end
    for i in unavailables
      add_actor(i.id)
    end
    $game_player.refresh
    $game_allies.compact.each { |i| i.refresh }
  end
  
end

#------------------------------------------------------------------------------
class Game_Actor < Game_Battler
  
  attr_accessor :ammos
  attr_accessor :skill_hotkeys
  attr_accessor :item_hotkeys
  
  alias vtp_gactor_setup setup
  alias vtp_gactor_forget_skill forget_skill
  
  def setup(actor_id)
    vtp_gactor_setup(actor_id)
    @ammos = {}
    @skill_hotkeys = {}
    @item_hotkeys = {}
  end
  
  def forget_skill(skill_id)
    vtp_gactor_forget_skill(skill_id)
    @skill_hotkeys.delete(@skill_hotkeys.index(skill_id))
  end
  
  def atk_animation_id
    return (weapons[0] == nil ? 1 : weapons[0].animation_id)
  end
  
  def atk_animation_id2
    return (weapons[1] == nil ? 1 : weapons[1].animation_id)
  end
  
  def display_level_up(new_skills)
    return if dead?
    @character.animation_id = 40
    @damage = "Level Up"
  end
  
  def current_exp
    return (@exp - @exp_list[@level])
  end
  
  def next_exp
    return (@exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0)
  end
  
  def attack_speed
    return 30
  end
  
end

#------------------------------------------------------------------------------
class Game_Enemy < Game_Battler
  
  attr_accessor :level
  
  alias vtp_genemy_initialize initialize
  
  def initialize(index, enemy_id)
    vtp_genemy_initialize(index, enemy_id)
    @level = 1
  end
  
  def base_maxhp
    return enemy.maxhp * ([@level, 1].max * 1.25)
  end
  
  def base_maxmp
    return enemy.maxmp * ([@level, 1].max * 1.25)
  end
  
  def base_atk
    return enemy.atk * ([@level, 1].max * 1.25)
  end
  
  def base_def
    return enemy.def * ([@level, 1].max * 1.25)
  end
  
  def base_spi
    return enemy.spi * ([@level, 1].max * 1.25)
  end
  
  def base_agi
    return enemy.agi * ([@level, 1].max * 1.25)
  end
  
  def name
    return (@level > 1 ? "#{enemy.name} #{Vocab.level_a}#{@level}" : enemy.name)
  end
  
  def character_name
    enemy.note.read("Character")
  end
  
  def character_index
    enemy.note.read("Index")
  end
  
  def respawn
    enemy.note.read("Respawn")
  end
  
  def move_speed
    enemy.note.read("Move Speed", 3)
  end
  
  def atk_animation_id
    enemy.note.read("Attack Animation", 1)
  end
  
  def aggressiveness
    enemy.note.read("Aggressiveness", 3)
  end
  
  def weapon_icon
    enemy.note.read("Weapon Icon")
  end
  
  def shield_icon
    enemy.note.read("Shield Icon")
  end
  
  def guard_rate
    enemy.note.read("Guard Rate", 50)
  end
  
  def attack_speed
    return 60
  end
  
  def on_enemy_walk
    if slip_damage?
      enemy.hp -= 1 if enemy.hp > 1
    end
  end
  
end

#------------------------------------------------------------------------------
class Game_Map
  
  alias vtp_hmap_passable passable?
  alias vtp_gmap_setup_events setup_events
  
  def passable?(x, y, flag = 0x01)
    for monster in $game_monsters.compact
      next if monster.actor.dead?
      return false if x == monster.x and y == monster.y
    end
    vtp_hmap_passable(x, y, flag)
  end
  
  def passable2?(x, y, flag = 0x01)
    for ally in $game_allies.compact
      next if ally.actor.dead?
      next if ally.in_vehicle?
      return false if x == ally.x and y == ally.y
    end
    return passable?(x, y)
  end
  
  def range_passable?(x, y)
    return true if @passages[@map.data[x, y, 0]] == 9
    return passable?(x, y)
  end
  
  def setup_events
    vtp_gmap_setup_events
    $game_monsters.clear
    for area in $data_areas.values
      next if area.map_id != @map_id
      for i in area.encounter_list
        read_level = $data_troops[i].name[/Lv\d+/i]
        level = (read_level == nil ? 1 : read_level[/\d+/].to_i)
        for m in $data_troops[i].members
          $game_monsters << Game_Monster.new(m.enemy_id, m.id, level, area)
        end
      end
    end
    for i in encounter_list
      read_level = $data_troops[i].name[/Lv\d+/i]
      level = (read_level == nil ? 1 : read_level[/\d+/].to_i)
      for m in $data_troops[i].members
        $game_monsters << Game_Monster.new(m.enemy_id, m.id, level, nil)
      end
    end
  end
  
end

#------------------------------------------------------------------------------
class Game_Character
  
  attr_accessor :damage
  attr_accessor :critical
  attr_accessor :actor
  attr_accessor :attack_delay
  attr_accessor :attack2_delay
  attr_accessor :skill_delay
  attr_accessor :item_delay
  attr_accessor :animation_delay
  attr_accessor :balloon_delay
  attr_accessor :right_attack
  attr_accessor :left_attack
  attr_accessor :defending
  attr_accessor :target
  attr_accessor :heal_target
  
  alias vtp_gcharacter_initialize initialize
  alias vtp_gcharacter_update update
  
  def initialize
    vtp_gcharacter_initialize
    @attack_delay = 0
    @attack2_delay = 0
    @skill_delay = 0
    @item_delay = 0
    @defend_delay = 0
    @animation_delay = 0
    @state_delay = 0
    @balloon_delay = 0
  end
  
  def update
    vtp_gcharacter_update
    update_delay
    update_actions
    update_states
    update_attack_movement if @animation_delay > 0
  end
  
  def update_delay
    @attack_delay -= 1 if @attack_delay > 0
    @attack2_delay -= 1 if @attack2_delay > 0
    @skill_delay -= 1 if @skill_delay > 0
    @item_delay -= 1 if @item_delay > 0
    @defend_delay -= 1 if @defend_delay > 0
    @animation_delay -= 1 if @animation_delay > 0
    @balloon_delay -= 1 if @balloon_delay > 0
  end
  
  def update_attack_movement   
    return if is_object?
    if @animation_delay >= 20
      @pattern = 0
    elsif @animation_delay.between?(10, 20)
      @pattern = 1
    elsif @animation_delay.between?(1, 10)
      @pattern = 2
    elsif @animation_delay.between?(0, 1)
      @pattern = 1
    end
  end
  
  def update_states
    return if @actor == nil
    return if @actor.dead?
    return if is_object?
    for state in @actor.states.compact
      if @state_delay <= (state.hold_turn*Graphics.frame_rate)
        @state_delay += 1
      elsif @state_delay > (state.hold_turn*Graphics.frame_rate)
        if rand(101) <= state.auto_release_prob
          @actor.remove_state(state.id)
        end
        @state_delay = 0
      end
    end
  end
  
  def step_back
    old_speed = @move_speed
    @move_speed = 6
    move_backward
    move_backward
    @move_speed = old_speed
  end
  
  def update_actions
  end
  
  def check_event_trigger_touch(x, y)
  end
  
  def in_vehicle?
    return false
  end
  
  def is_object?
    return false
  end
  
  def unkileable?
    return false
  end
  
end

#------------------------------------------------------------------------------
class Game_Event < Game_Character
  
  alias vtp_gevent_refresh refresh
  alias vtp_gevent_update update
  
  def refresh
    vtp_gevent_refresh
    setup_enemy
  end
  
  def update
    vtp_gevent_update
    update_enemy
  end
  
  def setup_enemy
    return if @erased
    @enemy_id = check_comment("Enemy").to_i
    return if @enemy_id <= 0
    @actor = Game_Enemy.new(0, @enemy_id)
    @actor.character = self
    @respawn_delay = @actor.respawn.to_i
    @die_switch = check_comment("Die Switch").to_i
    @die_selfswitch = check_comment("Die Self Switch").to_s.upcase
    @die_variable = check_comment("Die Variable").to_i      
    @actor.recover_all
    @opacity = 255
    @dead = false
    @death_triggerd = false
  end
  
  def update_enemy
    return if @actor == nil
    if !@actor.dead?
      update_target_selection
    elsif @actor.dead?
      update_death unless @dead
      @opacity -= 10 if @opacity > 0 and !@death_triggerd
    end
    if @dead and @respawn_delay.to_i > 0
      if @respawn_delay <= 1
        @erased = false
        refresh
      else
        @respawn_delay -= 1
      end
    end
  end
  
  def update_target_selection
    return if is_object?
    return if @target != nil
    for target in $VTP.select_target(self)
      next if $VTP.same_team?(self, target)
      next unless in_range?(target, 5)
      @target = target
    end
  end
  
  def update_actions
    return if $game_map.interpreter.running?
    return if @target != nil and @target.in_vehicle?
    $VTP.enemy_actions(self)
    @heal_target = nil
    @defending = (@defend_delay > 0)
  end
  
  def update_death
    if is_object?
      update_triggers
      @dead = true
      return
    end
    $VTP.make_drop(self)
    update_triggers
    @dead = true
  end
  
  def update_triggers
    if @die_switch > 0
      $game_switches[@die_switch] = !$game_switches[@die_switch]
    elsif @die_selfswitch != ""
      key = [$game_map.map_id, @id, @die_selfswitch]
      $game_self_switches[key] = !$game_self_switches[key]
    elsif @die_variable > 0
      $game_variables[@die_variable] += 1
    else
      erase
    end
    if @die_switch > 0 or @die_selfswitch != "" or @die_variable > 0
      @death_triggerd = true
      $game_map.need_refresh = true
    end
  end
  
  def update_self_movement
    return if @actor != nil and @actor.dead?
    return if @attack_delay > 0 or @skill_delay > 0
    return if $VTP.blocked_by_state?(self, 2)
    if follow_target? and @stop_count > 30 * (5 - @move_frequency)
      move_toward(@target)
    else
      super
    end
  end
  
  def increase_steps
    super
    return if @actor == nil
    return if @actor.dead?
    @actor.on_enemy_walk
  end
  
  def follow_target?
    return false if is_object?
    return false if @actor == nil
    return false if @actor.dead?
    return false if @target == nil
    return true if in_range?(@target, 5)
    return false
  end
  
  def is_object?
    return comment_exists?("Object")
  end
  
  def unkileable?
    return comment_exists?("Unkileable")
  end
  
  def map_passable?(x, y)
    return $game_map.passable2?(x, y)
  end
  
end

#------------------------------------------------------------------------------
class Game_Player < Game_Character
  
  attr_reader :selecting_skill
  attr_reader :selecting_item
  attr_reader :selecting_action
  attr_reader :ally_action
  
  alias vtp_gplayer_refresh refresh
  alias vtp_gplayer_update update
  alias vtp_gplayer_move_by_input move_by_input
  alias vtp_gplayer_perform_transfer perform_transfer
  
  def refresh
    vtp_gplayer_refresh
    @actor = $game_party.members[0]
    @actor.character = self if @actor != nil
  end
  
  def update
    vtp_gplayer_update
    return if @actor == nil
    if $game_party.all_dead?
      $game_temp.next_scene = "gameover"
    elsif @actor.dead?
      $game_party.change_group_order
    end    
  end
  
  def update_actions
    return if @actor == nil
    return if in_vehicle?
    return if $game_map.interpreter.running?
    update_right_hand
    update_left_hand
    update_skills_items_usage
    update_allies_actions
  end
  
  def update_right_hand
    if Input.trigger?($VTP.attack_key)
      return if $VTP.blocked_by_state?(self, 0)
      return if @defending
      return if @attack_delay > 0
      @right_attack = true
      if @actor.weapons[0] != nil and @actor.weapons[0].ranged?
        $VTP.range_attack(self, 0)
      else
        @target = nil
        for target in $VTP.select_target(self)
          next if $VTP.same_team?(self, target)
          next unless self.in_front?(target)
          @target = target
        end
        $VTP.melee_attack(self, @target)
      end
    end
    if @right_attack and @attack_delay <= 0
      @right_attack = false
      @target = nil
    end
  end
  
  def update_left_hand
    if @actor.two_swords_style
      if Input.trigger?($VTP.defend_key)
        return if $VTP.blocked_by_state?(self, 0)
        return if @attack2_delay > 0
        @left_attack = true
        if @actor.weapons[1] != nil and @actor.weapons[1].ranged?
          $VTP.range_attack(self, 1)
        else
          @target = nil
          for target in $VTP.select_target(self)
            next if $VTP.same_team?(self, target)
            next unless self.in_front?(target)
            @target = target
          end
          $VTP.melee_attack2(self, @target)
        end
      end
    else
      if Input.press?($VTP.defend_key)
        return if @actor.two_swords_style
        return unless @actor.armors[0].is_a?(RPG::Armor)
        @defending = true
      else
        @defending = false
      end
    end
    if @left_attack and @attack2_delay <= 0
      @left_attack = false
      @target = nil
    end
  end
  
  def update_skills_items_usage
    @selecting_skill = Input.press?($VTP.skills_key)
    @selecting_item = Input.press?($VTP.items_key)
    if @selecting_skill
      return if @selecting_item
      return if @skill_delay > 0
      @actor.skill_hotkeys.each { |k, v|
        next unless Input.trigger?(k)
        next if $VTP.blocked_by_state?(self, 1)
        if $data_skills[v].ranged?
          $VTP.cast_skill(self, $data_skills[v])
        else
          $VTP.skill_attack(self, $data_skills[v])
        end
      }
    end
    if @selecting_item
      return if @selecting_skill
      return if @item_delay > 0
      @actor.item_hotkeys.each { |k, v|
        next unless Input.trigger?(k)
        if $data_items[v].ranged?
          $VTP.cast_item(self, $data_items[v])
        else
          $VTP.item_attack(self, $data_items[v])
        end
      }
    end
  end
  
  def update_allies_actions
    return if $game_party.members.size < 2
    @selecting_action = Input.press?($VTP.allies_key)
    if !@selecting_action
      @ally_action = nil
      @old_action = nil
    end
    return unless @selecting_action
    @action_delay -= 1 if @action_delay != nil and @action_delay > 0
    if Input.trigger?(Input::DOWN)
      Sound.play_decision
      $game_party.change_group_order
      @action_delay = 5
    end
    if @ally_action == nil
      if Input.trigger?(8)
        Sound.play_decision
        @ally_action = $game_allies[1]
        @action_delay = 5
      elsif Input.trigger?(4)
        return if $game_party.members.size < 3
        Sound.play_decision
        @ally_action = $game_allies[2]
        @old_action = @ally_action.action
        @action_delay = 5
      elsif Input.trigger?(6)
        return if $game_party.members.size < 4
        Sound.play_decision
        @ally_action = $game_allies[3]
        @old_action = @ally_action.action
        @action_delay = 5
      end
    elsif @ally_action != nil and @action_delay <= 0
      if Input.trigger?(8)
        Sound.play_equip
        @ally_action.action = 0
      elsif Input.trigger?(4)
        Sound.play_equip
        @ally_action.action = 2
      elsif Input.trigger?(6)
        Sound.play_equip
        @ally_action.action = 1
      elsif Input.trigger?(2)
        Sound.play_equip
        @ally_action.action = 3
      end
    end
  end
  
  def move_by_input
    return if $VTP.blocked_by_state?(self, 2)
    return if @right_attack and @actor.weapons[0] != nil
    return if @left_attack and @actor.weapons[1] != nil
    return if @selecting_skill or @selecting_item or @selecting_action
    vtp_gplayer_move_by_input
  end
  
  def perform_transfer
    vtp_gplayer_perform_transfer
    for ally in $game_allies.compact
      ally.target = nil
      ally.moveto(@new_x, @new_y)
      ally.move_random
    end
    $game_items.clear
    if $game_variables[$VTP.battle_area_variable] > 0
      $game_variables[$VTP.battle_area_variable] = 0
    end
  end
  
end

#------------------------------------------------------------------------------
class Game_Ally < Game_Character
  
  attr_accessor :action
  
  def initialize(actor_id)
    super()
    @actor_id = actor_id
    @action = 0
    @in_vehicle = false
    @protect = false
    refresh
  end
  
  def refresh
    @actor = $game_party.members[@actor_id]
    @actor.character = self
    if @actor.dead? or in_vehicle?
      @character_name = ""
      @character_index = 0
    else
      @character_name = @actor.character_name
      @character_index = @actor.character_index
    end
  end
  
  def update
    super
    update_death
    return if @actor.dead?
    update_on_off_vehicle
    return if in_vehicle?
    update_target_selection
  end
  
  def update_actions
    return if @actor.dead?
    return if in_vehicle?
    return if $game_map.interpreter.running?
    case @action
    when 0
      update_weapon_attack
    when 1
      update_skill_attack
    when 3
      update_cure
    end
    @defending = (@action == 2)
  end
  
  def update_target_selection
    for ally in $game_allies.compact
      next if ally.action != 3
      next unless $game_map.in_range?(ally)
      next if ally.balloon_delay <= 0
      next unless in_range?(ally, 2)
      @target = ally
      @protect = true
    end
    if @target.is_a?(Game_Ally) and in_range?(@target, 2)
      @target = nil
      @protect = false
    end
    if @target == nil and !@protect
      for item in $game_items.compact
        next unless $game_map.in_range?(item)
        next if item.target != nil
        @target = item
        item.target = self
      end
    end
    if @target == nil and @action < 2 and !@protect
      for target in $VTP.select_target(self, nil)
        next unless $game_map.in_range?(target)
        next if target.is_object?
        next if $VTP.same_team?(self, target)
        next if target.actor.dead?
        next unless in_range?(target, 5)
        @target = target
      end
    end
    @target = $game_player if @defending
  end
  
  def update_weapon_attack
    @right_attack = (@attack_delay > 0)
    @left_attack = (@attack2_delay > 0)
    return if $VTP.blocked_by_state?(self, 0)
    if @actor.two_swords_style
      hand = rand(2)
    else
      hand = 0
    end
    return if @target == nil
    return if @target.is_a?(Game_Item)
    return if @target.is_object?
    return if $VTP.same_team?(self, @target)
    return if (hand == 0 and @attack_delay > 0) or (hand == 1 and @attack2_delay > 0)
    return unless self.in_front?(@target)
    weapon = @actor.weapons[hand]
    if weapon != nil and weapon.ranged?
      return unless (in_direction?(@target) and in_range?(@target, weapon.range))
      ammos = []
      weapon.ammo_list.each { |i| ammos << i if $game_party.has_item?($data_items[i]) }
      @actor.ammos[weapon.id] = $data_items[ammos[rand(ammos.size)]]
      $VTP.range_attack(self, hand)
    else
      if hand == 1
        $VTP.melee_attack2(self, @target)
      else
        $VTP.melee_attack(self, @target)
      end
    end
  end
  
  def update_skill_attack
    return if @skill_delay > 0
    return if $VTP.blocked_by_state?(self, 1)
    return if @actor.skills.empty?
    if @actor.skill_hotkeys.empty?
      skill = @actor.skills[rand(@actor.skills.size)]
    else
      skill = $data_skills[@actor.skill_hotkeys[@actor.skill_hotkeys.keys[rand(@actor.skill_hotkeys.size)]]]
    end
    if skill.ranged?
      for target in $VTP.select_target(self, skill)
        next if target.is_object?
        next if $VTP.same_team?(self, target)
        next unless in_range?(target, skill.range)
        next unless in_direction?(target)
        @target = target
        $VTP.cast_skill(self, skill)
      end
    else
      $VTP.skill_attack(self, skill)
    end
  end
  
  def update_cure
    if @target != nil and in_range?(@target, 2) and @balloon_delay <= 0
      @balloon_id = 1
      @balloon_delay = 60
    end
    party = []
    $game_party.members.each { |i| party << i.character }
    for target in party
      next unless $game_map.in_range?(target)
      for skill in @actor.skills.compact
        next if @skill_delay > 0
        next unless $VTP.curable?(target, skill)
        @heal_target = [target]
        $VTP.skill_attack(self, skill)
      end
      for item in $game_party.items
        next unless item.is_a?(RPG::Item)
        next if @item_delay > 0
        next unless $VTP.curable?(target, item)
        @heal_target = [target]
        $VTP.item_attack(self, item)
      end
    end
    @heal_target = nil
  end
  
  def update_death
    if @actor.dead? and !@dead
      Sound.play_actor_collapse
      for monster in $game_monsters.compact
        monster.target = nil if monster.target == self
      end
      for event in $game_map.events.values.compact
        event.target = nil if event.target == self
      end
      @dead = true
      refresh
    elsif !@actor.dead? and @dead
      refresh
      moveto($game_player.x, $game_player.y)
      move_random
      @dead = false
    end
  end
  
  def update_self_movement
    return if moving?
    return if @right_attack or @left_attack
    return if $VTP.blocked_by_state?(self, 2)
    if @target != nil
      if @action == 3 and (!@target.is_a?(Game_Item) or @target == $game_player)
        move_away_from(@target)
      else
        move_toward(@target)
      end
    else
      move_toward($game_player)
    end
    if @target.is_a?(Game_Item) and over?(@target)
      @target.get
      @target = nil
    end
  end
  
  def update_on_off_vehicle
    if $game_player.in_vehicle? and !@in_vehicle
      @in_vehicle = true
      refresh
    elsif !$game_player.in_vehicle? and @in_vehicle
      @in_vehicle = false
      refresh
      moveto($game_player.x, $game_player.y)
      move_random
    end
  end
  
  def get_on_vehicle
    @in_vehicle = true
    refresh
  end
  
  def get_off_vehicle
    @in_vehicle = false
    refresh
    moveto($game_player.x, $game_player.y)
    move_random
  end
  
  def map_passable?(x, y)
    return $game_map.passable2?(x, y)
  end
  
  def dash?
    return ($game_player.dash? and $game_player.moving?)
  end
  
  def in_vehicle?
    return @in_vehicle
  end
  
end

#------------------------------------------------------------------------------
class Game_Monster < Game_Character
  
  attr_reader :level
  
  def initialize(enemy_id, troop_id, level, area)
    super()
    @enemy_id = enemy_id
    @troop_id = troop_id
    @level = level
    @area = area
    setup_enemy
    set_start_position
    while(!map_passable?(@x_pos, @y_pos))
      set_start_position
    end
    moveto(@x_pos, @y_pos)
  end
  
  def setup_enemy
    @actor = Game_Enemy.new(0, @enemy_id)
    @actor.level = @level
    @actor.recover_all
    @actor.character = self
    @move_speed = @actor.move_speed.to_i
    @respawn_delay = @actor.respawn.to_i
    @dead = false
    refresh
  end
  
  def refresh    
    @character_name = @actor.character_name.to_s
    @character_index = @actor.character_index.to_i
    @opacity = 255
  end
  
  def update
    super
    if @actor.dead?
      update_death unless @dead
      @opacity -= 10 if @opacity > 0
    end
    if @dead and @respawn_delay > 0
      if @respawn_delay <= 1
        setup_enemy
      else
        @respawn_delay -= 1
      end
    end
  end
  
  def update_actions
    return if $game_map.interpreter.running?
    return if @target != nil and @target.in_vehicle?
    $VTP.enemy_actions(self)
    @heal_target = nil
    @defending = (@defend_delay > 0)
  end
  
  def set_start_position
    x = []; y = []
    if @area != nil
      for a in (@area.rect.x)...(@area.rect.x+@area.rect.width)
        for b in (@area.rect.y)...(@area.rect.y+@area.rect.height)
          next unless $game_map.passable?(a, b)
          x << a; y << b
        end
      end
    else
      for a in 0...$game_map.width
        for b in 0...$game_map.height
          next unless map_passable?(a, b)
          x << a; y << b
        end
      end
    end
    @x_pos = x[rand(x.size)]
    @y_pos = y[rand(y.size)]
  end
  
  def update_death
    $VTP.make_drop(self)
    @dead = true
  end
  
  def update_self_movement
    return if @actor.dead?
    return if moving?
    return if @attack_delay > 0
    return if $VTP.blocked_by_state?(self, 2)
    update_target_selection if @actor.aggressiveness.to_i != 2
    if @target != nil
      move_by_aggressiveness
    else
      move_random
    end
  end
  
  def update_target_selection
    return @target != nil
    for target in $VTP.update_target_selection(self)
      next if $VTP.same_team?(self, target)
      next if  @vision != nil and in_range?(target, @vision)
      @target = target
    end
  end
  
  def move_by_aggressiveness
    case @actor.aggressiveness.to_i
    when 0
      if @target != nil and in_range?(@target, 5)
        move_away_from(@target)
      else
        move_random
      end
    when 1
      if @target != nil and in_range?(@target, 5)
        move_type_away_from(@target)
      else
        move_random
      end
    when 2
      if @target != nil and in_range?(@target, 5)
        move_type_toward(@target)
      else
        move_random
      end
    when 3
      if @target != nil and in_range?(@target, 5)
        move_type_toward(@target)
      else
        move_random
      end
    when 4
      if @target != nil and in_range?(@target, 7)
        move_toward(@target)
      else
        move_random
      end
    when 5
      if @target != nil and in_range?(@target, 10)
        move_toward(@target)
      else
        move_random
      end
    end
  end
  
  def increase_steps
    super
    return if @actor == nil
    return if @actor.dead?
    @actor.on_enemy_walk
  end
  
  def map_passable?(x, y)
    return $game_map.passable2?(x, y)
  end
  
end

#------------------------------------------------------------------------------
class Game_Projectile < Game_Character
  
  attr_reader :parent
  attr_accessor :draw
  attr_accessor :destroy
  
  def initialize(parent, object)
    super()
    @parent = parent
    @object = object
    @actor = @parent.actor
    @step = 0
    @direction = @parent.direction
    @move_speed = @object.move_speed.to_i
    @step_anime = true
    moveto(@parent.x, @parent.y)
    refresh
    update
  end
  
  def refresh
    @character_name = @object.character.to_s
    @character_index = @object.index.to_i
  end
  
  def update
    super
    if @step > @object.range
      @destroy = true
      $game_projectiles.delete(self)
      return
    end
    return if moving?
    move_forward
    @step += 1
    dx = (@direction == 4 ? -1 : @direction == 6 ? 1 : 0)
    dy = (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
  end
  
  def check_event_trigger_touch(x, y)
    if @object.is_a?(RPG::Skill)
      $VTP.skill_attack(@parent, @object, self)
    elsif @object.is_a?(RPG::Item)
      $VTP.item_attack(@parent, @object, self)
    end
    @destroy = true
    $game_projectiles.delete(self)
  end
  
  def map_passable?(x, y)
    return $game_map.range_passable?(x, y)
  end
  
end

#------------------------------------------------------------------------------
class Game_Item < Game_Character
  
  attr_reader :item
  attr_accessor :draw
  attr_accessor :destroy
  
  def initialize(parent, item)
    super()
    @item = item
    if parent.is_a?(Array)
      moveto(parent[0], parent[1])
    else
      moveto(parent.x, parent.y)
      a = [-1, 0, 1]
      new_x = a[rand(a.size)]
      new_y = a[rand(a.size)]
      map_passable?(@x+new_x, @y+new_y) ? jump(new_x, new_y) : jump(0, 0)
    end
  end
  
  def update
    super
    return unless Input.trigger?(Input::C)
    return unless $game_player.in_front?(self) or $game_player.over?(self)
    get
  end
  
  def get
    $game_allies.compact { |ally| ally.target = nil if ally.target == self }
    Sound.play_decision
    @item.is_a?(Numeric) ? $game_party.gain_gold(@item) : $game_party.gain_item(@item, 1)
    @destroy = true
    $game_items.delete(self)
  end
  
  def screen_z
    return $game_player.screen_z - 1
  end
  
end

#------------------------------------------------------------------------------
class Game_Interpreter
  
  attr_reader :id
  
  alias vtp_ginterpreter_setup setup
  
  def setup(list, event_id=0)
    vtp_ginterpreter_setup(list, event_id)
    @id = @original_event_id
  end
  
  def create_item(object, kind, x, y)
    case kind
    when 0
      item = $data_items[object]
    when 1
      item = $data_weapons[object]
    when 2
      item = $data_armors[object]
    when 3
      item = object
    end
    $game_items << Game_Item.new([x, y], item)
  end
  
end

#------------------------------------------------------------------------------
class Sprite
  
  def draw_face(actor, x, y)
    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
    src_rect = Rect.new((char_index%4*3+1)*cw, (char_index/4*4)*ch, cw, 20)
    self.bitmap.blt(x, y+6, bitmap, src_rect)
  end
  
end

#------------------------------------------------------------------------------
class Sprite_Base
  
  attr_reader :character
  
  alias vtp_spbase_initialize initialize
  alias vtp_spbase_update update
  alias vtp_spbase_dispose dispose
  
  def initialize(viewport=nil)
    vtp_spbase_initialize(viewport)
    @damage_sprites = []
    @state_animation_delay = 0
    create_hits_sprite
  end
  
  def update
    vtp_spbase_update
    @state_animation_delay -= 1 if @state_animation_delay > 0
    update_damage_sprites
    update_hits_sprite
    update_states_animations
  end
  
  def dispose
    vtp_spbase_dispose
    dispose_damage_sprites
    dispose_hits_sprite
  end
  
  def update_damage_sprites
    for i in @damage_sprites.compact
      next if i[0].disposed?
      i[0].x = self.x
      i[0].y -= 0.25
    end
    for i in @damage_sprites.compact
      if i[1] > 0
        i[1] -= 1
      elsif !i[0].disposed?
        if i[0].opacity > 0
          i[0].opacity -= 10
        else
          i[0].dispose
          @damage_sprites.delete(i[0])
        end
      end
    end
    if @character != nil and @character.actor != nil and @character.damage != nil
      @character.step_back if @character.critical
      show_damage(@character.damage, @character.critical)
      @character.damage = nil
      @character.critical = false
    end
  end
  
  def dispose_damage_sprites
    @damage_sprites.each { |i| i[0].dispose }
    @damage_sprites.clear
  end
  
  def show_damage(damage, critical)
    string = (damage.is_a?(Numeric) ? damage.abs.to_i : damage)
    if damage.to_i == 0
      color = Color.new(255,255,255)
    elsif damage.to_i < 0
      color = Color.new(128,255,128)
    else      
       if @character.is_a?(Game_Player) or @character.is_a?(Game_Ally)
         color = Color.new(255,56,16)
       else
         color = Color.new(255,255,255)
       end
    end
    bitmap = Bitmap.new(100, $VTP.damage["font"][1]*2)
    bitmap.font.name = $VTP.damage["font"][0]
    bitmap.font.size = $VTP.damage["font"][1]
    bitmap.font.color = Color.new(255,204,32)
    bitmap.draw_outlined_text(0, 0, 100, bitmap.font.size, $VTP.damage["texts"][1], 1) if critical
    bitmap.font.color = color
    bitmap.draw_outlined_text(0, bitmap.font.size, 100, bitmap.font.size, string.to_s, 1)
    sprite = Sprite.new(self.viewport)
    sprite.bitmap = bitmap
    sprite.ox = bitmap.width/2
    sprite.oy = bitmap.height/2
    sprite.x = self.x
    sprite.y = self.y-32
    sprite.z = 999999
    @damage_sprites << [sprite, 30]
  end
  
  def create_hits_sprite
    @hits_sprite = Sprite.new(self.viewport)
    @hits_sprite.bitmap = Bitmap.new(200, $VTP.hit["font"][1]*3)
    @hits_sprite.bitmap.font.name = $VTP.hit["font"][0]
    @hits_sprite.bitmap.font.size = $VTP.hit["font"][1]
    @hits_sprite.bitmap.font.bold = $VTP.hit["font"][2]
    @hits_sprite.bitmap.font.italic = $VTP.hit["font"][3]
    @hits_sprite.x = $VTP.hit["position"][0]
    @hits_sprite.y = $VTP.hit["position"][1]
    @hits_sprite.z = 999999
    @hits_sprite.opacity = 0
    @hits_delay = 0
  end
  
  def update_hits_sprite
    @hits_delay -= 1 if @hits_delay > 0
    if $VTP.hits_total > 0 and @num_hits != $VTP.hits_total
      @num_hits = $VTP.hits_total
      w = @hits_sprite.bitmap.width
      h = @hits_sprite.bitmap.font.size
      @hits_sprite.bitmap.clear
      @hits_sprite.bitmap.font.color = Color.new(255,255,255)
      @hits_sprite.bitmap.draw_text($VTP.hits_total.getw+4, 0, w, h, $VTP.hit["texts"][0])
      @hits_sprite.bitmap.draw_text($VTP.damage_total.getw+4, h, w, h, $VTP.hit["texts"][1])
      @hits_sprite.bitmap.font.color = Color.new(255,204,32)
      @hits_sprite.bitmap.draw_text(0, 0, w, h, $VTP.hits_total.to_s)
      @hits_sprite.bitmap.font.color = Color.new(255,56,16)
      @hits_sprite.bitmap.draw_text(0, h, w, h, $VTP.damage_total.to_s)
      @hits_sprite.bitmap.fill_rect(0, h*2+1, w, 1, Color.new(0,0,0))
      @hits_sprite.bitmap.fill_rect(0, h*2, w, 1, Color.new(255,255,255))
      @hits_sprite.opacity = 255
      @hits_delay = 60
    end
    @hits_sprite.opacity -= 10 if @hits_delay <= 0 and @hits_sprite.opacity > 0
  end
  
  def dispose_hits_sprite
    @hits_sprite.dispose
  end
  
  def update_states_animations
    return if @character == nil
    return if @character.actor == nil
    return if @character.in_vehicle?
    for state in @character.actor.states.compact
      next if state.animation_id.to_i <= 0
      next if @state_animation_delay > 0
      @character.animation_id = state.animation_id.to_i
      @state_animation_delay = ($data_animations[@character.animation_id].frame_max*4+1)
    end
  end
  
  def animation_set_sprites(frame)
    cell_data = frame.cell_data
    for i in 0..15
      sprite = @animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern == nil or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @animation_bitmap1
      else
        sprite.bitmap = @animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if @animation_mirror
        sprite.x = @animation_ox - cell_data[i, 1] / 3
        sprite.y = @animation_oy + cell_data[i, 2] / 3
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = @animation_ox + cell_data[i, 1] / 3
        sprite.y = @animation_oy + cell_data[i, 2] / 3
        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] / 300.0
      sprite.zoom_y = cell_data[i, 3] / 300.0
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end
  
end
#------------------------------------------------------------------------------
class Sprite_Character < Sprite_Base
  
  alias vtp_spcharacter_update update
  
  def update
    vtp_spcharacter_update
    if @character.actor != nil
      if @character.actor.dead? and !@flash
        self.flash(Color.new(200,0,0), 10)
        @flash = true
      elsif @flash and !@character.actor.dead?
        @flash = false
      end
    end
  end
  
end

#------------------------------------------------------------------------------
class Sprite_Weapon < Sprite
  
  attr_reader :character
  
  def initialize(viewport, character)
    super(viewport)
    @character = character
    self.bitmap = Cache.system("Iconset")
    self.ox = 12
    self.oy = 12
    self.zoom_x = 0.80
    self.zoom_y = 0.80
    @animation_delay = 0
    refresh
    update
  end
  
  def update
    super
    @animation_delay -= 1 if @animation_delay > 0
    @animation_delay = 20 if @animation_delay <= 0 and @character.animation_delay >= 30
    self.visible = (@animation_delay > 0 and show?)
    return unless self.visible
    refresh
    update_movement
  end
  
  def refresh
    self.src_rect.set(icon_index%16*24, icon_index/16*24, 24, 24)
  end
  
  def update_movement
    case @character.direction
    when 2
      self.x = @character.screen_x-12
      self.y = @character.screen_y
      self.z = @character.screen_z+2
      self.mirror = false
      change_angle(180, 135, 90)
    when 4
      self.x = @character.screen_x-14
      self.y = @character.screen_y-10
      self.z = @character.screen_z-1
      self.mirror = false
      change_angle(-45, 0, 45)
    when 6
      self.x = @character.screen_x+14
      self.y = @character.screen_y-10
      self.z = @character.screen_z+2
      self.mirror = true
      change_angle(45, 0, -45)
    when 8
      self.x = @character.screen_x+16
      self.y = @character.screen_y-14
      self.z = @character.screen_z-1
      self.mirror = true
      change_angle(45, 0, -45)
    end
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
  end
  
  def change_angle(a, b, c)
    if @animation_delay >= 20
      self.angle = a
    elsif @animation_delay >= 15
      self.angle = b
    elsif @animation_delay >= 10
      self.angle = c
    end
  end
  
  def icon_index
    return 0 if @character.actor == nil
    return 0 if @character.in_vehicle?
    return @character.actor.weapon_icon.to_i if (@character.is_a?(Game_Monster) or @character.is_a?(Game_Event))
    if @character.left_attack
      return 0 if @character.actor.weapons[1] == nil
      return @character.actor.weapons[1].icon_index
    else
      return 0 if @character.actor.weapons[0] == nil
      return @character.actor.weapons[0].icon_index
    end
  end
  
  def show?
    return false if @character.actor == nil
    return false if @character.actor.dead?
    return true if @character.is_a?(Game_Monster) or @character.is_a?(Game_Event)
    return true if @character.right_attack
    return true if @character.left_attack
    return false
  end
  
end

#------------------------------------------------------------------------------
class Sprite_Shield < Sprite
  
  attr_reader :character
  
  def initialize(viewport, character)
    super(viewport)
    @character = character
    self.bitmap = Cache.system("Iconset")
    self.ox = 12
    self.oy = 12
    self.zoom_x = 0.80
    self.zoom_y = 0.80
    self.src_rect.set(icon_index%16*24, icon_index/16*24, 24, 24)
    update
  end
  
  def update
    super
    self.visible = (@character.defending and icon_index > 0 and !@character.actor.dead?)
    return unless self.visible
    update_movement
    moving_with_shield
  end
  
  def update_movement
    case @character.direction
    when 2
      self.mirror = true
      self.x = @character.screen_x+6
      self.z = @character.screen_z+1
    when 4
      self.mirror = false
      self.x = @character.screen_x-6
      self.z = @character.screen_z+1
    when 6
      self.mirror = true
      self.x = @character.screen_x+6
      self.z = @character.screen_z-1
    when 8
      self.mirror = false
      self.x = @character.screen_x-6
      self.z = @character.screen_z-1
    end
    self.y = @character.screen_y-8
    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 icon_index
    return 0 if @character.actor == nil
    return 0 if @character.in_vehicle?
    return @character.actor.shield_icon.to_i if (@character.is_a?(Game_Monster) or @character.is_a?(Game_Event))
    return 0 if @character.actor.armors[0] == nil
    return 0 unless @character.actor.armors[0].is_a?(RPG::Armor)
    return @character.actor.armors[0].icon_index
  end
  
end
#------------------------------------------------------------------------------
class Sprite_Item < Sprite
  
  attr_reader :character
  
  def initialize(viewport, character)
    super(viewport)
    @character = character
    self.bitmap = Cache.system("Iconset")
    self.ox = 12
    self.oy = 24
    index = @character.item.is_a?(Numeric) ? $VTP.gold_properties[0] : @character.item.icon_index
    self.src_rect.set(index%16*24, index/16*24, 24, 24)
    update
  end
  
  def update
    super
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z
    self.bush_depth = @character.bush_depth
  end
  
end

#------------------------------------------------------------------------------
class Sprite_Reward < Sprite
  
  def initialize(viewport)
    super(viewport)
    self.visible = false
    @duration = 0
  end
  
  def update
    refresh if $game_party.reward != nil
    return unless self.visible
    super
    @duration -= 1 if @duration > 0
    if @duration <= 0 and self.visible
      self.opacity -= 10
      self.visible = false if self.opacity <= 0
    end
    if @duration > 0 and self.visible and self.opacity < 200
      self.opacity += 10
    end
  end
  
  def refresh
    @text = $game_party.reward
    $game_party.reward = nil
    create_background
    self.bitmap.draw_text(self.bitmap.rect, @text, 1)
    self.x = Graphics.width - self.bitmap.width
    self.y = Graphics.height - self.bitmap.height
    self.visible = true
    @duration = 150
  end
  
  def create_background
    bitmap = Cache.system("Window")
    w, h = @text.getw+16, Font.default_size+16
    self.bitmap = Bitmap.new(w, h)
    self.bitmap.stretch_blt(Rect.new(4,4,w-8,h-8), bitmap, Rect.new(0,0,64,64))
    self.bitmap.stretch_blt(Rect.new(0,0,8,8), bitmap, Rect.new(64,0,8,8))    
    self.bitmap.stretch_blt(Rect.new(8,0,w-16,8), bitmap, Rect.new(72,0,48,8))
    self.bitmap.stretch_blt(Rect.new(w-8,0,8,8), bitmap, Rect.new(120,0,8,8))
    self.bitmap.stretch_blt(Rect.new(0,8,8,h-16), bitmap, Rect.new(64,8,8,48))
    self.bitmap.stretch_blt(Rect.new(0,h-8,8,8), bitmap, Rect.new(64,56,8,8))
    self.bitmap.stretch_blt(Rect.new(8,h-8,w-16,8), bitmap, Rect.new(72,56,48,8))
    self.bitmap.stretch_blt(Rect.new(w-8,h-8,8,8), bitmap, Rect.new(120,56,8,8))
    self.bitmap.stretch_blt(Rect.new(w-8,8,8,h-16), bitmap, Rect.new(120,8,8,48))
  end
  
end

#------------------------------------------------------------------------------
class Spriteset_Map
  
  alias vtp_spmap_create_characters create_characters
  alias vtp_spmap_update_characters update_characters
  alias vtp_spmap_dispose_characters dispose_characters
  
  def create_characters
    @allies_sprites = []
    @monsters_sprites = []
    @projectiles_sprites = []
    @items_sprites = []
    @weapons_sprites = []
    @shields_sprites = []
    vtp_spmap_create_characters
    @weapons_sprites << Sprite_Weapon.new(@viewport1, $game_player)
    @shields_sprites << Sprite_Shield.new(@viewport1, $game_player)
    for i in $game_map.events.values.compact
      next if i.actor == nil
      @weapons_sprites << Sprite_Weapon.new(@viewport1, i)
      @shields_sprites << Sprite_Shield.new(@viewport1, i)
    end
    for i in $game_allies.compact
      @allies_sprites << Sprite_Character.new(@viewport1, i)
      @weapons_sprites << Sprite_Weapon.new(@viewport1, i)
      @shields_sprites << Sprite_Shield.new(@viewport1, i)
    end
    for i in $game_monsters.compact
      @monsters_sprites << Sprite_Character.new(@viewport1, i)
      @weapons_sprites << Sprite_Weapon.new(@viewport1, i)
      @shields_sprites << Sprite_Shield.new(@viewport1, i)
    end
    for i in $game_projectiles.compact
      @projectiles_sprites << Sprite_Character.new(@viewport1, i)
    end
    for i in $game_items.compact
      @items_sprites << Sprite_Item.new(@viewport1, i)
    end
    @sprite_reward = Sprite_Reward.new(@viewport3)
  end
  
  def update_characters
    vtp_spmap_update_characters
    for i in @allies_sprites.compact
      next if i.disposed?
      i.update if $game_map.in_range?(i.character)
    end
    for i in @monsters_sprites.compact
      next if i.disposed?
      i.update if $game_map.in_range?(i.character)
    end
    for i in @weapons_sprites.compact
      next if i.disposed?
      i.update  if $game_map.in_range?(i.character)
    end
    for i in @shields_sprites.compact
      next if i.disposed?
      i.update  if $game_map.in_range?(i.character)
    end
    for i in @projectiles_sprites.compact
      next if i.disposed?
      if i.character.destroy
        i.dispose
        @projectiles_sprites.delete(i)
      elsif $game_map.in_range?(i.character)
        i.update
      end
    end
    for i in $game_projectiles.compact
      next if i.draw
      @projectiles_sprites << Sprite_Character.new(@viewport1, i)
      i.draw = true
    end
    for i in @items_sprites.compact
      next if i.disposed?
      if i.character.destroy
        i.dispose
        @items_sprites.delete(i)
      elsif $game_map.in_range?(i.character)
        i.update
      end
    end
    for i in $game_items.compact
      next if i.draw
      @items_sprites << Sprite_Item.new(@viewport1, i)
      i.draw = true
    end
    @sprite_reward.update
  end
  
  def dispose_characters
    vtp_spmap_dispose_characters
    @allies_sprites.compact.each { |i| i.dispose }
    @monsters_sprites.compact.each { |i| i.dispose }
    @weapons_sprites.compact.each { |i| i.dispose }
    @shields_sprites.compact.each { |i| i.dispose }
    @items_sprites.compact.each { |i| i.dispose }
    @sprite_reward.dispose
  end
  
  def refresh_allies_sprites
    @allies_sprites.compact.each { |i| i.dispose }
    @weapons_sprites.compact.each { |i| i.dispose if i.character.is_a?(Game_Ally) }
    @shields_sprites.compact.each { |i| i.dispose if i.character.is_a?(Game_Ally) }
    @allies_sprites.clear
    for i in $game_allies.compact
      @allies_sprites << Sprite_Character.new(@viewport1, i)
      @weapons_sprites << Sprite_Weapon.new(@viewport1, i)
      @shields_sprites << Sprite_Shield.new(@viewport1, i)
    end
  end
  
end

#------------------------------------------------------------------------------
class Scene_Title < Scene_Base
  
  alias vtp_stitle_command_new_game command_new_game
  alias vtp_stitle_create_game_objects create_game_objects
  
  def create_game_objects
    $game_allies = []
    $game_monsters = []
    $game_projectiles = []
    $game_items = []
    vtp_stitle_create_game_objects
    $VTP = VerusTempusProelium.new
  end
  
  def command_new_game
    vtp_stitle_command_new_game
    for ally in $game_allies.compact
      ally.moveto($data_system.start_x, $data_system.start_y)
    end
  end
  
end

#------------------------------------------------------------------------------
class Scene_File < Scene_Base
  
  alias vtp_stitle_do_load do_load
  alias vtp_stitle_read_save_data read_save_data
  alias vtp_stitle_write_save_data write_save_data
  
  def do_load
    vtp_stitle_do_load
    $game_player.refresh
    $game_allies.compact.each { |i| i.refresh }
  end
  
  def read_save_data(file)
    vtp_stitle_read_save_data(file)
    $game_allies      = Marshal.load(file)
    $game_monsters    = Marshal.load(file)
    $game_projectiles = Marshal.load(file)
    $game_items       = Marshal.load(file)
    $VTP              = Marshal.load(file)
  end
  
  def write_save_data(file)
    vtp_stitle_write_save_data(file)
    Marshal.dump($game_allies,      file)
    Marshal.dump($game_monsters,    file)
    Marshal.dump($game_projectiles, file)
    Marshal.dump($game_items,       file)
    Marshal.dump($VTP,              file)
  end
  
end

#------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  
  alias vtp_smap_update update
  
  def update
    vtp_smap_update
    $VTP.update
    $game_allies.compact.each { |i| i.update if $game_map.in_range?(i) }
    $game_monsters.compact.each { |i| i.update if $game_map.in_range?(i) }
    $game_projectiles.compact.each { |i| i.update if $game_map.in_range?(i) }
    $game_items.compact.each { |i| i.update if $game_map.in_range?(i) }
  end
  
  def refresh_allies_sprites
    @spriteset.refresh_allies_sprites if @spriteset != nil
  end
  
  def update_encounter
  end
  
end

#------------------------------------------------------------------------------
class Window_Selectable < Window_Base
  
  alias vtp_wselectable_cursor_down cursor_down
  alias vtp_wselectable_cursor_left cursor_left
  alias vtp_wselectable_cursor_right cursor_right
  alias vtp_wselectable_cursor_up cursor_up
  
  def cursor_down(wrap=false)
    return if is_skill or is_item
    vtp_wselectable_cursor_down(wrap)
  end
  
  def cursor_left(wrap=false)
    return if is_skill or is_item
    vtp_wselectable_cursor_left(wrap)
  end
  
  def cursor_right(wrap=false)
    return if is_skill or is_item
    vtp_wselectable_cursor_right(wrap)
  end
  
  def cursor_up(wrap=false)
    return if is_skill or is_item
    vtp_wselectable_cursor_up(wrap)
  end
  
  def is_skill
    return true if self.is_a?(Window_Skill) and Input.press?($VTP.skills_key)
    return false
  end
  
  def is_item
    return true if self.is_a?(Window_Item) and Input.press?($VTP.items_key)
    return false
  end
  
end

#------------------------------------------------------------------------------
class Scene_Item < Scene_Base
  
  alias vtp_sitem_start start
  alias vtp_sitem_update_item_selection update_item_selection
  
  def start
    vtp_sitem_start
    @actor = $game_party.members[0]
  end
  
  def update_item_selection
    vtp_sitem_update_item_selection
    if Input.press?($VTP.items_key)
      return unless Input.trigger?(Input.dir4)
      Sound.play_use_item
      @actor.item_hotkeys[Input.dir4] = @item_window.item.id
    end
    if Input.trigger?($VTP.attack_key)
      return if @actor.weapons[0] == nil
      return unless @actor.weapons[0].ranged?
      return unless @actor.weapons[0].ammo_list.include?(@item_window.item.id)
      @actor.ammos[@actor.weapons[0].id] = @item_window.item.id
      Sound.play_equip
    end
    if Input.trigger?($VTP.defend_key)
      return unless @actor.two_swords_style
      return if @actor.weapons[1] == nil
      return unless @actor.weapons[1].ranged?
      return unless @actor.weapons[1].ammo_list.include?(@item_window.item.id)
      @actor.ammos[@actor.weapons[1].id] = @item_window.item.id
      Sound.play_equip
    end
  end
  
end

#------------------------------------------------------------------------------
class Scene_Skill < Scene_Base
  
  def update_skill_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
      @skill = @skill_window.skill
      if @skill != nil
        @actor.last_skill_id = @skill.id
      end
      if @actor.skill_can_use?(@skill)
        Sound.play_decision
        determine_skill
      else
        Sound.play_buzzer
      end
    end
    if Input.press?($VTP.skills_key)
      return unless Input.trigger?(Input.dir4)
      Sound.play_use_skill
      @actor.skill_hotkeys[Input.dir4] = @skill_window.skill.id
    end
  end
  
end

#==============================================================================
# End of Verus Tempus Proelium
#==============================================================================