Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==============================================================================
- # 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
- #==============================================================================
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement