View difference between Paste ID: CGfbK45n and

-
+#==============================================================================
 # 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
 =begin
   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
 =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_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
 #==============================================================================