Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==============================================================================
- # Requiem ABS 9.0
- #==============================================================================
- # Credits: Vlad | Email: requiem@rodcats.com
- #------------------------------------------------------------------------------
- if Requiem_Masterpiece.enabled?("Requiem Keyboard") and
- Requiem_Masterpiece.enabled?("Requiem Extended Movements", 1.5)
- #------------------------------------------------------------------------------
- Requiem_Masterpiece.register("Requiem ABS", 9.0, "07/28/2009")
- #------------------------------------------------------------------------------
- # Tasto per l'attacco
- Attack_Key1 = Keys::A
- # Tasto per lo scudo o la seconda arma
- Attack_Key2 = Keys::S
- # Tasti usati per le magie
- Skill_Keys = [Keys::Num1, Keys::Num2, Keys::Num3]
- # Tasti usati per gli oggetti
- Item_Keys = [Keys::Q, Keys::W, Keys::E]
- # Tasto per cambiare l'ordine del gruppo.
- Group_Order_Key = Keys::Tab
- # Variable used to build battle areas
- # * Quando un nemico muore, questa variabile riceve +1
- # * Quando il player cambia mappa, questa mappa viene settata a 0
- Battle_Area_Variable = 0
- # Mostrare l'icona dell'arma quando attacca?
- Allow_Weapons_Graphics = true
- # Mostrare l'icona dello scudo quando si difende?
- Allow_Shields_Graphics = true
- # Permettere al plyer di attacare e difendersi allo stesso tempo?
- Allow_attack_with_shield = false
- # Permettere il conteggio dei colpi e i combo?
- Allow_Combo_Damage = true
- # Recuperare HP e MP quando sale di livello?
- Recovery_When_LevelUp = true
- # Through dropped items on map?
- Through_Drop = true
- # Mostrare il nome dell'oggetto quando viene raccolto?
- Show_Reward = true
- # Usare il calcolatore automatico di EXP e Gold?
- # (Questo metodo ignora l'EXP e il Gold settati nel database)
- Auto_EXP_Gold = true
- # Dividi l'EXP tra i membri del party?
- # (se รจ false, l'esperienza va a chi a ucciso il mostro)
- Divide_EXP = true
- # Permettere di cambiare il personaggio tramite pressione del bottone?
- Change_Group_Order = true
- # Quando il primo pg muore, passare automaticamente al prossimo?
- Next_Actor_If_Dead = true
- # Indice dell'icona dell'oro che viene lasciato per terra
- Gold_Drop_Icon_Index = 147
- # % di ricevere oro (0 ~ 100)
- Gold_Drop_Rate = 75
- # Tempo che gli oggetti rimangono sulla mappa (In frames)
- Drop_Duration_Time = 600
- # Auto Exp data dai nemici (In %)
- Auto_EXP_Rate = 5
- # Auto Gold dato dai nemici (In %)
- Auto_Gold_Rate = 10
- # Animazione mostrata quando il pg sale di livello
- LevelUp_Animation = 40
- # Dividi l'animazione in:
- Animations_Divide = 3
- # Testo da mostrare quando una skill o un oggetto sono associati ad un tasto
- Memorized_Text = "Memorizzato!"
- # SE da attivare quando viene trovato oro
- Gold_Drop_SE = ""
- # SE da attivare quando viene trovato un oggetto
- Item_Drop_SE = ""
- Fonts = {}
- # Nome | Grandezza | Grassetto | Corsivo
- Fonts["Dano"] = ["Verdana", 18, true, false]
- Fonts["Golpes"] = ["Times New Roman", 26, true, true]
- Fonts["Recompensa"] = ["Verdana", 16, false, false]
- Damage_Texts = ["Mancato", "Critico", "Combo", "Difende", "Salito di livello", "Colpi", "Rifette"]
- Damage_Colors = [Color.new(255,255,255), # Normale
- Color.new(102,204,64), # Cura
- Color.new(255,255,64), # Critico
- Color.new(255,56,16), # Combo
- Color.new(160,152,255), # Riflette
- Color.new(153,204,255)] # Colpisce
- #------------------------------------------------------------------------------
- class Requiem_ABS
- attr_reader :attack_key1
- attr_reader :attack_key2
- attr_reader :skill_keys
- attr_reader :item_keys
- attr_reader :group_order_key
- attr_reader :animations_divide
- attr_reader :memorized_text
- attr_reader :allow_weapons_graphics
- attr_reader :allow_shields_graphics
- attr_reader :allow_attack_with_shield
- attr_reader :allow_combo_damage
- attr_reader :levelup_animation
- attr_reader :recovery_when_levelup
- attr_reader :gold_drop_icon_index
- attr_reader :gold_drop_rate
- attr_reader :drop_duration_time
- attr_reader :show_reward
- attr_reader :drop_se
- attr_reader :auto_exp_e_gold
- attr_reader :auto_exp_rate
- attr_reader :auto_gold_rate
- attr_reader :damage_properties
- attr_reader :through_drop
- attr_reader :divide_exp
- attr_reader :change_group_order
- attr_reader :next_actor_if_dead
- attr_reader :battle_area_variable
- def initialize
- @attack_key1 = Attack_Key1
- @attack_key2 = Attack_Key2
- @skill_keys = Skill_Keys
- @item_keys = Item_Keys
- @group_order_key = Group_Order_Key
- @animations_divide = Animations_Divide
- @memorized_text = Memorized_Text
- @allow_weapons_graphics = Allow_Weapons_Graphics
- @allow_shields_graphics = Allow_Shields_Graphics
- @allow_attack_with_shield = Allow_attack_with_shield
- @allow_combo_damage = Allow_Combo_Damage
- @levelup_animation = LevelUp_Animation
- @recovery_when_levelup = Recovery_When_LevelUp
- @gold_drop_icon_index = Gold_Drop_Icon_Index
- @gold_drop_rate = Gold_Drop_Rate
- @drop_duration_time = Drop_Duration_Time
- @show_reward = Show_Reward
- @drop_se = [Gold_Drop_SE, Item_Drop_SE]
- @auto_exp_e_gold = Auto_EXP_Gold
- @auto_exp_rate = Auto_EXP_Rate
- @auto_gold_rate = Auto_Gold_Rate
- @through_drop = Through_Drop
- @divide_exp = Divide_EXP
- @change_group_order = Change_Group_Order
- @next_actor_if_dead = Next_Actor_If_Dead
- @battle_area_variable = Battle_Area_Variable
- @damage_properties = {}
- @damage_properties["Dano"] = Fonts["Dano"]
- @damage_properties["Golpes"] = Fonts["Golpes"]
- @damage_properties["Recompensa"] = Fonts["Recompensa"]
- @damage_properties["Texts"] = Damage_Texts
- @damage_properties["Colors"] = Damage_Colors
- end
- end
- #------------------------------------------------------------------------------
- # Module RPG
- #------------------------------------------------------------------------------
- module RPG
- class State
- def animation_id
- self.note.each_line { |line|
- return line.gsub('Animation = ', '').chomp.to_i if line.include?('Animation = ')
- }
- return 0
- end
- def walk_slower?
- self.note.each_line { |line| return true if line.include?("Walk Slower") }
- return false
- end
- def walk_faster?
- self.note.each_line { |line| return true if line.include?("Walk Faster") }
- return false
- end
- def dont_walk?
- self.note.each_line { |line| return true if line.include?("Don't Walk") }
- return false
- end
- def confusion?
- self.note.each_line { |line| return true if line.include?("Confusion") }
- return false
- end
- def duration
- self.note.each_line { |line|
- return line.gsub('Duration = ', '').chomp.to_i if line.include?('Duration = ')
- }
- return 300
- end
- end
- class BaseItem
- def ranged?
- self.note.each_line { |line| return true if line.include?("Ranged") }
- return false
- end
- def explosive?
- self.note.each_line { |line| return true if line.include?("Explosive") }
- return false
- end
- def bomb?
- self.note.each_line { |line| return true if line.include?("Bomb") }
- return false
- end
- def graphic
- self.note.each_line { |line|
- return line.gsub!('Graphic = ', '').chomp if line.include?('Graphic = ')
- }
- return ""
- end
- def index
- self.note.each_line { |line|
- return line.gsub('Index = ', '').chomp.to_i if line.include?('Index = ')
- }
- return 0
- end
- def move_speed
- self.note.each_line { |line|
- return line.gsub('Speed = ', '').chomp.to_i if line.include?('Speed = ')
- }
- return 4
- end
- def range
- self.note.each_line { |line|
- return line.gsub('Range = ', '').chomp.to_i if line.include?('Range = ')
- }
- return 5
- end
- def delay
- self.note.each_line { |line|
- return line.gsub('Delay = ', '').chomp.to_i if line.include?('Delay = ')
- }
- return 60
- end
- def area
- self.note.each_line { |line|
- return line.gsub('Area = ', '').chomp.to_i if line.include?('Area = ')
- }
- return 3
- end
- def shot_se
- self.note.each_line { |line|
- return line.gsub('Shot SE = ', '').chomp.to_s if line.include?('Shot SE = ')
- }
- return nil
- end
- def combo_hits
- self.note.each_line { |line|
- return line.gsub('Combo Hits = ', '').chomp.to_i if line.include?('Combo Hits = ')
- }
- return 5
- end
- def combo_rate
- self.note.each_line { |line|
- return line.gsub('Combo Rate = ', '').chomp.to_i if line.include?('Combo Rate = ')
- }
- return 75
- end
- def ammo1
- self.note.each_line { |line|
- return $data_items[line.gsub('Ammo1 = ', '').chomp.to_i] if line.include?('Ammo1 = ')
- }
- return nil
- end
- def ammo2
- self.note.each_line { |line|
- return $data_items[line.gsub('Ammo2 = ', '').chomp.to_i] if line.include?('Ammo2 = ')
- }
- return nil
- end
- def defense_rate
- self.note.each_line { |line|
- return line.gsub('Defense Rate = ', '').chomp.to_i if line.include?('Defense Rate = ')
- }
- return 50
- end
- def reflect_rate
- self.note.each_line { |line|
- return line.gsub('Reflect Rate = ', '').chomp.to_i if line.include?('Reflect Rate = ')
- }
- return 0
- end
- def path
- self.note.each_line { |line|
- return line.gsub!('Path = ', '').chomp if line.include?('Path = ')
- }
- return "Line"
- end
- end
- end
- #------------------------------------------------------------------------------
- # Bitmap
- #------------------------------------------------------------------------------
- class Bitmap
- def draw_outlined_text(x, y, w, h, s, a=0, c=Font.default_color)
- 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 = c
- draw_text(x, y, w, h, s, a)
- end
- end
- #------------------------------------------------------------------------------
- # Game Battler
- #------------------------------------------------------------------------------
- class Game_Battler
- attr_accessor :damage
- attr_accessor :critical
- attr_accessor :combo
- attr_accessor :reflect
- attr_accessor :state_turns
- attr_accessor :defending
- attr_accessor :piece
- alias requiem_abs_gbattler_initialize initialize
- alias requiem_abs_gbattler_make_obj_damage_value make_obj_damage_value
- def initialize
- @damage = 0
- requiem_abs_gbattler_initialize
- end
- def attack_effect(attacker)
- clear_action_results
- unless attack_effective?(attacker)
- @skipped = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- if rand(100) >= calc_hit(attacker)
- @missed = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- if rand(100) < calc_eva(attacker)
- @evaded = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- make_attack_damage_value(attacker)
- execute_damage(attacker)
- return if @hp_damage == 0
- apply_state_changes(attacker)
- end
- def skill_effect(user, skill)
- clear_action_results
- unless skill_effective?(user, skill)
- @skipped = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- if rand(100) >= calc_hit(user, skill)
- @missed = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- if rand(100) < calc_eva(user, skill)
- @evaded = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- make_obj_damage_value(user, skill)
- make_obj_absorb_effect(user, skill)
- execute_damage(user)
- return if skill.physical_attack and @hp_damage == 0
- apply_state_changes(skill)
- end
- def item_effect(user, item)
- clear_action_results
- unless item_effective?(user, item)
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- @skipped = true
- return
- end
- if rand(100) >= calc_hit(user, item)
- @missed = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- return
- end
- if rand(100) < calc_eva(user, item)
- @evaded = true
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- 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)
- return if item.physical_attack and @hp_damage == 0
- apply_state_changes(item)
- end
- def execute_damage(user)
- if @hp_damage == 0
- @damage = $Requiem_ABS.damage_properties["Texts"][0]
- elsif defending?(user)
- @damage = $Requiem_ABS.damage_properties["Texts"][3]
- return
- else
- if user.reflect
- user.damage = (@hp_damage/4 <= 0 ? 1 : @hp_damage/4)
- else
- @damage = @hp_damage
- end
- end
- remove_states_shock if @hp_damage > 0
- if user.reflect
- user.hp -= (@hp_damage/4 <= 0 ? 1 : @hp_damage/4)
- user.mp -= (@mp_damage/4 <= 0 ? 1 : @mp_damage/4)
- else
- self.hp -= @hp_damage
- self.mp -= @mp_damage
- end
- if @absorbed
- user.hp += @hp_damage
- user.mp += @mp_damage
- end
- end
- def make_attack_damage_value(attacker)
- damage = attacker.atk * 4 - self.def * 2
- damage = 0 if damage < 0
- damage *= elements_max_rate(attacker.element_set)
- damage /= 100
- if damage == 0
- damage = rand(2)
- elsif damage > 0
- attacker.reflect = (rand(100) < reflect_rate)
- @critical = (rand(100) < attacker.cri)
- @critical = false if prevent_critical or @reflect
- damage *= 2 if @critical
- calculate_combo(attacker)
- damage *= 3 if @combo
- damage = apply_variance(damage, 20)
- damage = apply_guard(damage)
- @hp_damage = damage
- end
- end
- def make_obj_damage_value(user, obj)
- requiem_abs_gbattler_make_obj_damage_value(user, obj)
- user.reflect = (rand(100) < reflect_rate)
- end
- def calculate_combo(attacker)
- if attacker.is_a?(Game_Actor) and $Requiem_ABS.allow_combo_damage
- if $game_player.right_attack_on and attacker.weapons[0] != nil
- hits = attacker.weapons[0].combo_hits
- rate = attacker.weapons[0].combo_rate
- elsif $game_player.left_attack_on and attacker.weapons[1] != nil
- hits = attacker.weapons[1].combo_hits
- rate = attacker.weapons[1].combo_rate
- elsif $game_player.right_attack_on and attacker.weapons[0].nil?
- hits = 5
- rate = 75
- elsif $game_player.left_attack_on and attacker.weapons[1].nil?
- hits = 5
- rate = 75
- else
- hits = rate = 0
- end
- @combo = ($game_player.hits >= hits and rand(100) <= rate)
- @combo = false if @reflect
- else
- @combo = false
- end
- end
- def attack_speed
- a = [[75, 75-(agi/10)].min, 3].max
- return a
- end
- def defending?(user)
- if self.is_a?(Game_Actor) and @defending and equips[1].is_a?(RPG::Armor) and
- rand(100) <= equips[1].defense_rate and @piece != nil and user.piece.face_to_face?(user.piece, @piece)
- return true
- elsif self.is_a?(Game_Monster) and @defending and rand(100) <= self.defense_rate and
- @piece != nil and user.piece.face_to_face?(user.piece, @piece)
- return true
- elsif self.is_a?(Game_Enemy) and @defending and rand(100) <= self.defense_rate and
- @piece != nil and user.piece.face_to_face?(user.piece, @piece)
- return true
- end
- return false
- end
- def remove_state(state_id)
- return unless state?(state_id)
- @states.delete(state_id)
- @state_turns.delete(state_id)
- end
- end
- #------------------------------------------------------------------------------
- # Game Actor
- #------------------------------------------------------------------------------
- class Game_Actor < Game_Battler
- attr_accessor :skill_hotkeys
- attr_accessor :item_hotkeys
- alias requiem_abs_gactor_initialize initialize
- def initialize(actor_id)
- requiem_abs_gactor_initialize(actor_id)
- @skill_hotkeys = {}
- for s in $Requiem_ABS.skill_keys
- @skill_hotkeys[s] = 0
- end
- @item_hotkeys = {}
- for i in $Requiem_ABS.item_keys
- @item_hotkeys[i] = 0
- end
- end
- def display_level_up(new_skills)
- $game_system.battle_end_me.play
- $game_player.animation_id = $Requiem_ABS.levelup_animation
- @damage = $Requiem_ABS.damage_properties["Texts"][4]
- recover_all if $Requiem_ABS.recovery_when_levelup
- end
- def atk_animation_id2
- if two_swords_style
- return weapons[1].nil? ? 1 : weapons[1].animation_id
- else
- return 1
- end
- end
- def reflect_rate
- r = 0
- for i in armors.compact
- r += i.reflect_rate
- end
- return r
- 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
- end
- #------------------------------------------------------------------------------
- # Game Enemy
- #------------------------------------------------------------------------------
- class Game_Enemy < Game_Battler
- def character_name
- enemy.note.each_line { |line|
- return line.gsub('Char Name = ', '').chomp if line.include?('Char Name = ')
- }
- return ""
- end
- def character_index
- enemy.note.each_line { |line|
- return line.gsub('Char Index = ', '').chomp.to_i if line.include?('Char Index = ')
- }
- return 0
- end
- def atk_animation_id
- enemy.note.each_line { |line|
- return line.gsub('Attack Animation = ', '').chomp.to_i if line.include?('Attack Animation = ')
- }
- return 1
- end
- def die_animation_id
- enemy.note.each_line { |line|
- return line.gsub('Die Animation = ', '').chomp.to_i if line.include?('Die Animation = ')
- }
- return 0
- end
- def die_se
- enemy.note.each_line { |line|
- return line.gsub('Die SE = ', '').chomp.to_s if line.include?('Die SE = ')
- }
- return nil
- end
- def weapon_icon
- enemy.note.each_line { |line|
- return line.gsub('Weapon Icon = ', '').chomp.to_i if line.include?('Weapon Icon = ')
- }
- return 0
- end
- def shield_icon
- enemy.note.each_line { |line|
- return line.gsub('Shield Icon = ', '').chomp.to_i if line.include?('Shield Icon = ')
- }
- return 0
- end
- def defense_rate
- enemy.note.each_line { |line|
- return line.gsub('Defense Rate = ', '').chomp.to_i if line.include?('Defense Rate = ')
- }
- return 50
- end
- def reflect_rate
- enemy.note.each_line { |line|
- return line.gsub('Reflect Rate = ', '').chomp.to_i if line.include?('Reflect Rate = ')
- }
- return 0
- end
- def move_speed
- enemy.note.each_line { |line|
- return line.gsub('Move Speed = ', '').chomp.to_i if line.include?('Move Speed = ')
- }
- return 3
- end
- def follow_range
- enemy.note.each_line { |line|
- return line.gsub('Follow Range = ', '').chomp.to_i if line.include?('Follow Range = ')
- }
- return 3
- end
- def move_route
- enemy.note.each_line { |line|
- return line.gsub('Move Route = ', '').chomp.to_i if line.include?('Move Route = ')
- }
- return 1
- end
- def respawn
- enemy.note.each_line { |line|
- return line.gsub('Respawn = ', '').chomp.to_i if line.include?('Respawn = ')
- }
- return 0
- end
- end
- #------------------------------------------------------------------------------
- # Game Party
- #------------------------------------------------------------------------------
- class Game_Party < Game_Unit
- alias requiem_sbabs_gparty_setup_starting_members setup_starting_members
- def setup_starting_members
- requiem_sbabs_gparty_setup_starting_members
- for i in 1...@actors.size
- next if @actors[i].nil?
- $game_allies[i] = Game_Ally.new(i)
- end
- end
- def add_actor(actor_id)
- if @actors.size < MAX_MEMBERS and not @actors.include?(actor_id)
- @actors.push(actor_id)
- $game_player.refresh
- 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
- end
- end
- $scene.refresh_sprites if $scene.is_a?(Scene_Map)
- end
- def remove_actor(actor_id)
- change_group_order if members[0].id == actor_id
- @actors.delete(actor_id)
- for ally in $game_allies.compact
- next if ally.actor.id != actor_id
- ally.destroy = true
- $game_allies.delete(ally)
- end
- $game_player.refresh
- $scene.refresh_sprites if $scene.is_a?(Scene_Map)
- end
- def change_group_order
- for ally in $game_allies.compact
- next if ally.map_id == $game_map.map_id
- return
- end
- return if members.size <= 1
- actor = @actors[0]
- @actors.delete(actor)
- @actors.compact
- if all_dead?
- @actors.insert(0, actor)
- return
- end
- @actors.push(actor)
- for a in members.compact
- if a.dead?
- ally = a
- @actors.delete(a.id)
- @actors.push(a.id)
- else
- for i in $game_allies.compact
- next if i.actor != a
- ally = i
- end
- break
- end
- end
- allies = []
- for a in $game_allies.compact
- allies.push(a)
- end
- allies.delete(ally)
- allies.push($game_player)
- allies.compact
- for i in 1...members.size
- next if members[i].nil?
- $game_allies[i] = Game_Ally.new(i)
- $game_allies[i].refresh
- $game_allies[i].moveto(allies[i-1].x, allies[i-1].y)
- if !allies[i-1].is_a?(Game_Player)
- $game_allies[i].map_id = allies[i-1].map_id
- else
- $game_allies[i].map_id = $game_map.map_id
- end
- $game_allies[i].direction = allies[i-1].direction
- end
- $game_player.moveto(ally.x, ally.y)
- $game_player.refresh
- $scene.refresh_sprites if $scene.is_a?(Scene_Map)
- end
- end
- #------------------------------------------------------------------------------
- # Game Map
- #------------------------------------------------------------------------------
- class Game_Map
- alias requiem_abs_gmap_passable passable?
- alias requiem_abs_gmap_setup_events setup_events
- def setup_events
- requiem_abs_gmap_setup_events
- $game_monsters.clear
- for area in $data_areas.values
- next unless area.map_id == @map_id
- for i in area.encounter_list
- for m in $data_troops[i].members
- $game_monsters.push(Game_Monster.new($game_monsters.size, m.enemy_id, m.id, area))
- end
- end
- end
- for i in encounter_list
- for m in $data_troops[i].members
- $game_monsters.push(Game_Monster.new($game_monsters.size, m.enemy_id, m.id, nil))
- end
- end
- end
- def range_passable?(x, y, flag = 0x01)
- return true if @passages[@map.data[x, y, 0]] == 9
- passable?(x, y, flag)
- end
- def player_passable?(x, y, flag = 0x01)
- all_passable?(x, y, flag)
- end
- def passable?(x, y, flag = 0x01)
- for ally in $game_allies.compact
- next if ally.character_name == ""
- return false if ally.x == x and ally.y == y
- end
- all_passable?(x, y, flag)
- end
- def all_passable?(x, y, flag = 0x01)
- for monster in $game_monsters.compact
- next if monster.actor.dead?
- return false if monster.x == x and monster.y == y
- end
- for drop in $game_drop.compact
- next if $Requiem_ABS.through_drop
- return false if drop.x == x and drop.y == y
- end
- for event in events_xy(x, y)
- next if event.tile_id == 0
- next if event.priority_type > 0
- next if event.through
- pass = @passages[event.tile_id]
- next if pass & 0x10 == 0x10
- return true if pass & flag == 0x00
- return false if pass & flag == flag
- end
- for i in [2, 1, 0]
- tile_id = @map.data[x, y, i]
- return false if tile_id == nil
- pass = @passages[tile_id]
- next if pass & 0x10 == 0x10
- return true if pass & flag == 0x00
- return false if pass & flag == flag
- end
- return false
- end
- def update_events
- for event in @events.values
- next unless in_range?(event) or event.trigger == 3 or event.trigger == 4
- event.update
- end
- for common_event in @common_events.values
- common_event.update
- end
- end
- def in_range?(object)
- return true if object.is_a?(Game_Event) and object.check_command("Force Update")
- return false if object.real_x < (@display_x-768)
- return false if object.real_x > (@display_x+5120)
- return false if object.real_y < (@display_y-768)
- return false if object.real_y > (@display_y+4096)
- return true
- end
- end
- #------------------------------------------------------------------------------
- # Game Character
- #------------------------------------------------------------------------------
- class Game_Character
- alias requiem_abs_gchar_initialize initialize
- alias requiem_abs_gchar_update update
- attr_accessor :actor
- attr_accessor :target
- attr_accessor :ani_time
- attr_accessor :state_time
- attr_accessor :weapon1_attack_time
- attr_accessor :weapon2_attack_time
- attr_accessor :assigned_skill
- attr_accessor :skill_attack_time
- attr_accessor :item_attack_time
- attr_accessor :recovery_time
- attr_accessor :right_attack_on
- attr_accessor :left_attack_on
- attr_accessor :freeze
- attr_accessor :anime_attack
- attr_accessor :lock_target
- attr_accessor :original_move_speed
- def initialize
- requiem_abs_gchar_initialize
- @weapon1_attack_time = 0
- @weapon2_attack_time = 0
- @skill_attack_time = 0
- @item_attack_time = 0
- @recovery_time = 0
- @assigned_skill = nil
- @ani_time = 0
- @anime_attack = 0
- @state_time = 0
- @original_move_speed = 0
- @actor = nil
- @target = nil
- @freeze = false
- @right_attack_on = false
- @left_attack_on = false
- @lock_target = false
- end
- def update
- requiem_abs_gchar_update
- return if $game_party.members.size <= 0
- decrease_counters
- states_effects
- end
- def decrease_counters
- @ani_time -= 1 if @ani_time > 0
- @weapon1_attack_time -= 1 if @weapon1_attack_time > 0
- @weapon2_attack_time -= 1 if @weapon2_attack_time > 0
- @skill_attack_time -= 1 if @skill_attack_time > 0
- @item_attack_time -= 1 if @item_attack_time > 0
- @recovery_time -= 1 if @recovery_time > 0
- @anime_attack -= 1 if @anime_attack > 0
- @right_attack_on = @left_attack_on = false if @anime_attack <= 0
- end
- def states_effects
- return unless is_battler?
- for state in @actor.states.compact
- if @state_time <= state.duration
- @state_time += 1
- @freeze = true if state.dont_walk?
- @move_speed = 2 if state.walk_slower?
- @move_speed = 5 if state.walk_faster?
- if is_enemy? and @actor.slip_damage?
- @actor.slip_damage_effect if Graphics.frame_count % 60 <= 0
- end
- elsif @state_time > state.duration
- @freeze = false if state.dont_walk?
- @move_speed = @original_move_speed if state.walk_slower?
- @move_speed = @original_move_speed if state.walk_faster?
- @actor.remove_state(state.id)
- @state_time = 0
- end
- end
- end
- def is_battler?
- return true if self.is_a?(Game_Player)
- return true if self.is_a?(Game_Ally)
- return true if self.is_a?(Game_Monster)
- return true if self.is_a?(Game_Event) and self.in_battle
- return false
- end
- def is_enemy?
- return true if self.is_a?(Game_Monster)
- return true if self.is_a?(Game_Event) and self.in_battle
- return false
- end
- end
- #------------------------------------------------------------------------------
- # Game Event
- #------------------------------------------------------------------------------
- class Game_Event < Game_Character
- attr_reader :in_battle
- attr_reader :kill_with_weapon
- attr_reader :kill_with_skill
- attr_reader :kill_with_item
- attr_reader :respawn
- attr_reader :boss
- attr_reader :object
- attr_reader :puzzle
- alias requiem_abs_gevent_initialize initialize
- alias requiem_abs_gevent_setup setup
- alias requiem_abs_gevent_update update
- alias requiem_abs_gevent_refresh refresh
- def initialize(map_id, event)
- @enemy_id = 0
- @respawn = nil
- @in_battle = false
- @boss = false
- @object = false
- @puzzle = false
- requiem_abs_gevent_initialize(map_id, event)
- end
- def setup(new_page)
- requiem_abs_gevent_setup(new_page)
- self.original_move_speed = @move_speed
- end
- def update
- requiem_abs_gevent_update
- @respawn -= 1 if !@in_battle and self.actor.nil? and @respawn != nil and @respawn > 0
- if @in_battle and self.actor != nil and !self.actor.dead?
- make_attack
- elsif @in_battle and self.actor != nil and self.actor.dead?
- kill_enemy
- erasing
- elsif !@in_battle and self.actor.nil? and @respawn != nil and @respawn <= 0
- @erased = @starting = false
- refresh
- end
- end
- def refresh
- requiem_abs_gevent_refresh
- @enemy_id = check_value("Enemy")
- @self_switch_a = check_command("Die Self Switch A")
- @self_switch_b = check_command("Die Self Switch B")
- @self_switch_c = check_command("Die Self Switch C")
- @self_switch_d = check_command("Die Self Switch D")
- @switch = check_value("Die Switch")
- @variable = check_value("Die Variable")
- @kill_with_weapon = check_value("Kill With Weapon")
- @kill_with_skill = check_value("Kill With Skill")
- @kill_with_item = check_value("Kill With Item")
- @boss = check_command("Boss")
- @object = check_command("Object")
- @puzzle = check_command("Puzzle")
- if @enemy_id > 0 and !@in_battle
- self.actor = Game_Enemy.new(0, @enemy_id)
- self.actor.recover_all
- @respawn = self.actor.respawn
- @respawn = nil if @respawn <= 0
- @follow_range = self.actor.follow_range
- self.actor.piece = self
- self.target = $game_player
- self.lock_target = false
- @in_battle = true
- elsif @enemy_id <= 0
- @in_battle = false
- end
- @opacity = 255
- @blend_type = 0
- end
- def make_attack
- return if $game_map.interpreter.running?
- return if $game_player.in_vehicle?
- for action in self.actor.enemy.actions
- next unless self.actor.conditions_met?(action)
- next unless rand(11) < action.rating
- next if self.weapon1_attack_time > 0
- case action.kind
- when 0
- case action.basic
- when 0
- attack_normal
- when 1
- self.actor.defending = true
- end
- when 1
- self.assigned_skill = $data_skills[action.skill_id]
- case self.assigned_skill.scope
- when 1...7
- if self.assigned_skill.ranged?
- if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
- skill_attack_range
- elsif action.rating == 10
- skill_attack_range
- else
- for ally in $game_allies.compact
- next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
- skill_attack_range
- end
- end
- elsif self.assigned_skill.explosive?
- if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
- skill_explode_range
- elsif action.rating == 10
- skill_explode_range
- else
- for ally in $game_allies.compact
- next unless in_direction?(self, ally) and in_range?(self, ally, self.assigned_skill.range)
- skill_explode_range
- end
- end
- else
- skill_attack_normal
- end
- when 7...12
- skill_recover
- end
- end
- end
- end
- def attack_normal
- for ally in $game_allies.compact
- next unless in_front?(self, ally)
- self.anime_attack = 20
- ally.animation_id = self.actor.atk_animation_id
- ally.actor.attack_effect(self.actor)
- ally.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- return
- end
- return if $game_player.actor.nil?
- return unless in_front?(self, $game_player)
- self.anime_attack = 20
- $game_player.animation_id = self.actor.atk_animation_id
- $game_player.actor.attack_effect(self.actor)
- $game_player.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- def skill_attack_normal
- return if self.actor.mp < self.assigned_skill.mp_cost
- for ally in $game_allies.compact
- next unless in_front?(self, ally)
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- ally.animation_id = self.assigned_skill.animation_id
- ally.actor.skill_effect(self.actor, self.assigned_skill)
- ally.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- return if $game_player.actor.dead?
- return unless in_front?(self, $game_player)
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_player.animation_id = self.assigned_skill.animation_id
- $game_player.actor.skill_effect(self.actor, self.assigned_skill)
- $game_player.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- def skill_attack_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
- self.weapon1_attack_time = self.assigned_skill.delay
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- end
- def skill_explode_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
- self.weapon1_attack_time = self.assigned_skill.delay
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- end
- def skill_recover
- if self.actor.mp >= self.assigned_skill.mp_cost and self.actor.hp <= (self.actor.maxhp*25/100)
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- @animation_id = self.assigned_skill.animation_id
- self.actor.skill_effect(self.actor, self.assigned_skill)
- self.weapon1_attack_time = self.assigned_skill.delay
- end
- for event in $game_map.events.values
- if event.in_battle and in_range?(self, event, 3)
- if self.actor.mp >= self.assigned_skill.mp_cost and event.actor.hp <= (event.actor.maxhp*25/100)
- self.actor.mp -= self.assigned_skill.mp_cost
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- event.animation_id = self.assigned_skill.animation_id
- event.actor.skill_effect(self.actor, self.assigned_skill)
- self.weapon1_attack_time = self.assigned_skill.delay
- end
- end
- end
- end
- def erasing
- return if @puzzle
- @blend_type = 2
- @opacity -= 5
- end
- def kill_enemy
- dying unless @killed
- return if @opacity > 0 and !@puzzle
- self.actor = nil
- desactive_enemy
- @killed = false
- $game_player.hits = 0
- @in_battle = false
- for ally in $game_allies.compact
- next if ally.actor.dead?
- ally.target = $game_player
- ally.lock_target = false
- end
- end
- def dying
- if $Requiem_ABS.auto_exp_e_gold and !@puzzle and !@object
- exp = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
- self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_exp_rate / 100
- else
- exp = self.actor.exp
- end
- if $Requiem_ABS.divide_exp
- x = (exp/$game_party.members.size)
- for i in $game_party.members
- i.gain_exp(x, true)
- end
- else
- self.target.actor.gain_exp(exp, true)
- end
- make_drop
- unless @puzzle
- @animation_id = self.actor.die_animation_id if self.actor.die_animation_id > 0
- if self.actor.die_se != nil
- RPG::SE.new(self.actor.die_se).play
- else
- Sound.play_enemy_collapse
- end
- end
- $game_variables[$Requiem_ABS.battle_area_variable] += 1 if $Requiem_ABS.battle_area_variable > 0
- @killed = true
- end
- def desactive_enemy
- if @self_switch_a
- key = [$game_map.map_id, self.id, "A"]
- $game_self_switches[key] = !$game_self_switches[key]
- elsif @self_switch_b
- key = [$game_map.map_id, self.id, "B"]
- $game_self_switches[key] = !$game_self_switches[key]
- elsif @self_switch_c
- key = [$game_map.map_id, self.id, "C"]
- $game_self_switches[key] = !$game_self_switches[key]
- elsif @self_switch_d
- key = [$game_map.map_id, self.id, "D"]
- $game_self_switches[key] = !$game_self_switches[key]
- elsif @switch > 0
- $game_switches[@switch] = !$game_switches[@switch]
- elsif @variable > 0
- $game_variables[@variable] += 1
- else
- erase
- end
- $game_map.need_refresh = true
- end
- def make_drop
- droped_items = []
- for i in [self.actor.drop_item1, self.actor.drop_item2]
- next if i.kind <= 0
- next if rand(i.denominator) != 0
- if i.kind == 1
- droped_items.push($data_items[i.item_id])
- elsif i.kind == 2
- droped_items.push($data_weapons[i.weapon_id])
- elsif i.kind == 3
- droped_items.push($data_armors[i.armor_id])
- end
- end
- for t in droped_items.compact
- $game_drop.push(Game_Drop.new(self, t.icon_index, t , 0))
- end
- if $Requiem_ABS.auto_exp_e_gold
- gold = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
- self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_gold_rate / 100
- else
- gold = self.actor.gold
- end
- if gold > 0 and rand(100) <= $Requiem_ABS.gold_drop_rate
- $game_drop.push(Game_Drop.new(self, $Requiem_ABS.gold_drop_icon_index, nil, gold))
- end
- end
- def update_self_movement
- return if self.freeze or (self.anime_attack/2) > 0
- return unless @stop_count > 30 * (5 - @move_frequency)
- if self.puzzle or self.object
- self.target = nil
- elsif @in_battle and in_range?(self, $game_player, @follow_range) and !self.lock_target
- self.target = $game_player
- self.lock_target = true
- end
- for ally in $game_allies.compact
- next if self.puzzle or self.object
- if @in_battle and in_range?(self, ally, @follow_range) and !ally.actor.dead? and !self.lock_target
- self.target = ally
- self.lock_target = true
- elsif self.target == ally and ally.actor.dead? and self.lock_target
- self.target = nil
- self.lock_target = false
- end
- end
- if self.target != nil and @in_battle and in_range?(self, self.target, @follow_range)
- move_type_toward(self.target)
- else
- case @move_type
- when 1
- move_type_random
- when 2
- move_type_toward_player
- when 3
- move_type_custom
- end
- end
- end
- end
- #------------------------------------------------------------------------------
- # Game Player
- #------------------------------------------------------------------------------
- class Game_Player < Game_Character
- attr_accessor :hit
- attr_accessor :hits
- attr_accessor :hit_time
- attr_accessor :assigned_item
- attr_accessor :reward
- alias requiem_abs_gplayer_initialize initialize
- alias requiem_abs_gplayer_refresh refresh
- alias requiem_abs_gplayer_update update
- alias requiem_abs_gplayer_move_by_input move_by_input
- alias requiem_abs_gplayer_perform_transfer perform_transfer
- def initialize
- requiem_abs_gplayer_initialize
- @hits = 0
- @hit_time = 0
- @assigned_item = 0
- @hit = nil
- @reward = nil
- self.original_move_speed = 4
- end
- def refresh
- self.actor = $game_party.members[0]
- self.actor.piece = self unless self.actor.nil?
- requiem_abs_gplayer_refresh
- end
- def update
- requiem_abs_gplayer_update
- return if self.actor.nil?
- return if $game_map.interpreter.running?
- return if in_vehicle?
- attack_with_weapon
- attack_with_skill
- attack_with_item
- auto_recovery
- update_hits
- if $Requiem_ABS.next_actor_if_dead
- $game_temp.next_scene = "gameover" if $game_party.all_dead?
- $game_party.change_group_order if self.actor.dead? and !$game_party.all_dead?
- elsif self.actor.dead?
- $game_temp.next_scene = "gameover"
- end
- if Input.trigger?($Requiem_ABS.group_order_key) and !Input.press?(Input::CTRL) and $Requiem_ABS.change_group_order
- $game_party.change_group_order
- end
- end
- def hit_count
- return unless $Requiem_ABS.allow_combo_damage
- @hits += 1
- @hit = "#{@hits}"
- end
- def update_hits
- if self.right_attack_on and @attack_weapon != nil
- @hits = 0 if @hit_time <= 0 or @hits >= @attack_weapon.combo_hits
- elsif self.left_attack_on and @attack_weapon_and_Shield != nil
- @hits = 0 if @hit_time <= 0 or @hits >= @attack_weapon_and_Shield.combo_hits
- elsif self.right_attack_on and @attack_weapon.nil?
- @hits = 0 if @hit_time <= 0 or @hits >= 5
- elsif self.left_attack_on and @attack_weapon_and_Shield.nil?
- @hits = 0 if @hit_time <= 0 or @hits >= 5
- end
- @hit_time -= 1 if @hit_time > 0
- end
- def attack_with_weapon
- if Input.trigger?($Requiem_ABS.attack_key1)
- return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
- return if self.weapon1_attack_time > 0
- @attack_weapon = self.actor.equips[0]
- RPG::SE.new(@attack_weapon.shot_se).play if @attack_weapon != nil and @attack_weapon.shot_se != nil
- self.anime_attack = 20
- self.right_attack_on = true
- self.left_attack_on = false
- if @attack_weapon != nil and @attack_weapon.ranged?
- range_attack_right
- self.weapon1_attack_time = @attack_weapon.delay
- @hit_time = self.weapon1_attack_time + 15
- else
- normal_attack_right
- self.weapon1_attack_time = self.actor.attack_speed
- @hit_time = self.weapon1_attack_time + 15
- end
- end
- if Input.press?($Requiem_ABS.attack_key2)
- self.actor.defending = (self.actor.equips[1].is_a?(RPG::Armor) and $Requiem_ABS.allow_shields_graphics)
- else
- self.actor.defending = false
- end
- if Input.trigger?($Requiem_ABS.attack_key2)
- return if self.weapon2_attack_time > 0
- return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
- @attack_weapon_and_Shield = (self.actor.two_swords_style ? self.actor.equips[1] : self.actor.equips[0])
- RPG::SE.new(@attack_weapon_and_Shield.shot_se).play if @attack_weapon_and_Shield != nil and @attack_weapon_and_Shield.shot_se != nil
- self.anime_attack = 20
- self.right_attack_on = false
- self.left_attack_on = true
- if @attack_weapon_and_Shield != nil and @attack_weapon_and_Shield.ranged?
- range_attack_left
- self.weapon2_attack_time = @attack_weapon_and_Shield.delay
- @hit_time = self.weapon2_attack_time + 15
- elsif self.actor.two_swords_style
- normal_attack_left
- self.weapon2_attack_time = self.actor.attack_speed
- @hit_time = self.weapon1_attack_time + 15
- end
- end
- end
- def attack_with_skill
- for button in self.actor.skill_hotkeys.keys
- if Input.trigger?(button) and self.actor.skill_hotkeys[button] != nil and self.actor.skill_hotkeys[button] != 0
- return if self.skill_attack_time > 0
- return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
- self.assigned_skill = $data_skills[self.actor.skill_hotkeys[button]]
- if self.assigned_skill.scope == 2
- skill_attack_all
- elsif self.assigned_skill.ranged?
- skill_attack_range
- elsif self.assigned_skill.explosive?
- skill_explode_range
- elsif self.assigned_skill.scope >= 7
- skill_recover
- else
- skill_attack_normal
- end
- end
- end
- end
- def attack_with_item
- for button in self.actor.item_hotkeys.keys
- if Input.trigger?(button) and self.actor.item_hotkeys[button] != nil and self.actor.item_hotkeys[button] != 0
- return if self.item_attack_time > 0
- return if !$Requiem_ABS.allow_attack_with_shield and self.actor.defending
- @assigned_item = $data_items[self.actor.item_hotkeys[button]]
- if @assigned_item.ranged?
- item_attack_range
- elsif @assigned_item.explosive?
- item_attack_explode
- elsif @assigned_item.bomb?
- item_attack_bomb
- else
- case @assigned_item.scope
- when 1
- item_normal_attack
- when 2
- item_attack_all
- when 3...7
- item_normal_attack
- when 7...12
- item_recover
- end
- end
- end
- end
- end
- def normal_attack_right
- for monster in $game_monsters.compact
- next unless in_front?(self, monster)
- next if monster.actor.dead?
- monster.animation_id = self.actor.atk_animation_id
- hit_count
- monster.actor.attack_effect(self.actor)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next unless in_front?(self, event)
- next if event.actor.dead? or event.object
- event.animation_id = self.actor.atk_animation_id
- hit_count
- return if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon.id or
- event.kill_with_skill > 0 or event.kill_with_item > 0
- event.actor.attack_effect(self.actor)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def range_attack_right
- return if @attack_weapon.ammo1 != nil and !$game_party.has_item?(@attack_weapon.ammo1)
- $game_party.consume_item(@attack_weapon.ammo1) if @attack_weapon.ammo1 != nil
- $game_range.push(Game_Range.new(self, @attack_weapon.graphic, @attack_weapon.index, @attack_weapon.move_speed, @attack_weapon.range, 1))
- end
- def normal_attack_left
- for monster in $game_monsters.compact
- next unless in_front?(self, monster)
- next if monster.actor.dead?
- monster.animation_id = self.actor.atk_animation_id2
- hit_count
- monster.actor.attack_effect(self.actor)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next unless in_front?(self,event)
- next if event.actor.dead? or event.object
- event.animation_id = self.actor.atk_animation_id2
- hit_count
- return if event.kill_with_weapon > 0 and event.kill_with_weapon != @attack_weapon_and_Shield.id or
- event.kill_with_skill > 0 or event.kill_with_item > 0
- event.actor.attack_effect(self.actor)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def range_attack_left
- return if @attack_weapon_and_Shield.ammo2 != nil and !$game_party.has_item?(@attack_weapon_and_Shield.ammo2)
- $game_party.consume_item(@attack_weapon_and_Shield.ammo2) if @attack_weapon_and_Shield.ammo2 != nil
- $game_range.push(Game_Range.new(self, @attack_weapon_and_Shield.graphic, @attack_weapon_and_Shield.index, @attack_weapon_and_Shield.move_speed, @attack_weapon_and_Shield.range, 2))
- end
- def skill_attack_normal
- for monster in $game_monsters.compact
- next unless in_front?(self, monster)
- next if monster.actor.dead?
- next unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- monster.animation_id = self.assigned_skill.animation_id
- self.skill_attack_time = self.assigned_skill.delay
- monster.actor.skill_effect(self.actor, self.assigned_skill)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next unless in_front?(self,event)
- next if event.actor.dead? or event.object
- next unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- event.animation_id = self.assigned_skill.animation_id
- self.skill_attack_time = self.assigned_skill.delay
- return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
- event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
- event.actor.skill_effect(self.actor, self.assigned_skill)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def skill_attack_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- self.skill_attack_time = self.assigned_skill.delay
- end
- def skill_attack_all
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- for monster in $game_monsters.compact
- next if monster.actor.dead?
- monster.animation_id = self.assigned_skill.animation_id
- self.skill_attack_time = self.assigned_skill.delay
- monster.actor.skill_effect(self.actor, self.assigned_skill)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next if event.actor.dead? or event.object
- event.animation_id = self.assigned_skill.animation_id
- self.skill_attack_time = self.assigned_skill.delay
- return if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
- event.kill_with_skill > 0 and event.kill_with_skill != self.assigned_skill.id
- event.actor.skill_effect(self.actor, self.assigned_skill)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def skill_explode_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- self.skill_attack_time = self.assigned_skill.delay
- end
- def skill_recover
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- self.actor.skill_effect(self.actor, self.assigned_skill)
- @animation_id = self.assigned_skill.animation_id
- self.skill_attack_time = 60
- end
- def item_normal_attack
- for monster in $game_monsters.compact
- next unless in_front?(self, monster)
- next if monster.actor.dead?
- next unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- monster.animation_id = @assigned_item.animation_id
- self.item_attack_time = @assigned_item.delay
- monster.actor.item_effect(self.actor, @assigned_item)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next unless in_front?(self,event)
- next if event.actor.dead? or event.object
- next unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- event.animation_id = @assigned_item.animation_id
- self.item_attack_time = @assigned_item.delay
- return if event.kill_with_weapon > 0 or event.kill_with_skill > 0 or
- event.kill_with_item > 0 and event.kill_with_item != self.assigned_item.id
- event.actor.item_effect(self.actor, @assigned_item)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def item_attack_range
- return unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- $game_range.push(Game_Range.new(self, @assigned_item.graphic, @assigned_item.index, @assigned_item.move_speed, @assigned_item.range, 5))
- RPG::SE.new(@assigned_item.shot_se).play if @assigned_item.shot_se != nil
- self.item_attack_time = @assigned_item.delay
- end
- def item_attack_explode
- return unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- $game_range.push(Game_Range.new(self, @assigned_item.graphic, @assigned_item.index, @assigned_item.move_speed, @assigned_item.range, 6))
- RPG::SE.new(@assigned_item.shot_se).play if @assigned_item.shot_se != nil
- self.item_attack_time = @assigned_item.delay
- end
- def item_recover
- return unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- @animation_id = @assigned_item.animation_id
- self.actor.item_effect(self.actor, @assigned_item)
- self.item_attack_time = @assigned_item.delay
- end
- def item_attack_all
- next unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- for monster in $game_monsters.compact
- next unless in_front?(self, monster)
- next if monster.actor.dead?
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- monster.animation_id = @assigned_item.animation_id
- self.item_attack_time = @assigned_item.delay
- monster.actor.item_effect(self.actor, @assigned_item)
- monster.jump(0,0)
- monster.target = self
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next if event.actor.dead? or event.object
- event.animation_id = @assigned_item.animation_id
- self.item_attack_time = @assigned_item.delay
- return if event.kill_with_weapon > 0 or event.kill_with_skill > 0 or
- event.kill_with_item > 0 and event.kill_with_item != self.assigned_item.id
- event.actor.item_effect(self.actor, @assigned_item)
- event.jump(0,0) unless event.puzzle
- event.target = self
- end
- end
- def item_attack_bomb
- return unless $game_party.has_item?(@assigned_item)
- $game_party.consume_item(@assigned_item)
- $game_temp.common_event_id = @assigned_item.common_event_id if @assigned_item.common_event_id > 0
- $game_bomb.push(Game_Bomb.new(self, @assigned_item))
- self.item_attack_time = 60
- end
- def auto_recovery
- return unless self.actor.auto_hp_recover and self.recovery_time <= 0
- self.actor.hp += (self.actor.maxhp*10/100)
- self.recovery_time = 1800
- end
- def perform_transfer
- requiem_abs_gplayer_perform_transfer
- for range in $game_range.compact
- range.destroy = true
- end
- for drop in $game_drop.compact
- drop.destroy = true
- end
- for bomb in $game_bomb.compact
- bomb.destroy = true
- end
- for ally in $game_allies.compact
- ally.perform_transfer(@new_map_id, @new_x, @new_y, @new_direction) unless ally.actor.dead?
- ally.refresh
- end
- $game_variables[$Requiem_ABS.battle_area_variable] = 0 if $Requiem_ABS.battle_area_variable > 0
- end
- def map_passable?(x, y)
- case @vehicle_type
- when 0
- return $game_map.boat_passable?(x, y)
- when 1
- return $game_map.ship_passable?(x, y)
- when 2
- return true
- else
- return $game_map.player_passable?(x, y)
- end
- end
- def move_by_input
- return if self.freeze or (self.anime_attack/2) > 0
- if self.actor != nil
- for state in self.actor.states.compact
- next unless state.confusion?
- return unless movable?
- return if $game_map.interpreter.running?
- case Input.dir4
- when 2,4,6,8
- move_random
- end
- return
- end
- end
- requiem_abs_gplayer_move_by_input
- end
- end
- #------------------------------------------------------------------------------
- # Game Ally
- #------------------------------------------------------------------------------
- class Game_Ally < Game_Character
- attr_reader :id
- attr_accessor :map_id
- attr_accessor :draw
- attr_accessor :destroy
- attr_accessor :command
- def initialize(id)
- super()
- @id = id
- @map_id = $game_map.map_id
- @command = 0
- @draw = false
- @destroy = false
- self.target = $game_player
- self.original_move_speed = 4
- refresh
- end
- def update
- super
- return if @destroy
- if self.actor.dead? and !@dead
- refresh
- @dead = true
- elsif !self.actor.dead? and @dead
- refresh
- @dead = false
- end
- if $game_player.in_vehicle? and !@in_vehicle and !self.actor.defending
- refresh
- @in_vehicle = true
- elsif !$game_player.in_vehicle? and @in_vehicle
- refresh
- moveto($game_player.x, $game_player.y) unless self.actor.dead?
- @in_vehicle = false
- end
- return if self.actor.nil? or self.actor.dead? or $game_player.in_vehicle?
- self.actor.defending = (@command == 2 ? true : false)
- make_action
- auto_recovery
- update_movement
- end
- def refresh
- self.actor = $game_party.members[@id]
- self.actor.piece = self
- if $game_player.in_vehicle? and !self.actor.dead? and !self.actor.defending
- @character_name = ""
- elsif self.actor.dead?
- if File.exists?("Graphics/Characters/$#{self.actor.name}_dead.png") and @map_id == $game_map.map_id
- @character_name = "$#{self.actor.name}_dead"
- @character_index = 0
- else
- @character_name = ""
- end
- elsif @map_id != $game_map.map_id
- @character_name = ""
- else
- @character_name = self.actor.character_name
- @character_index = self.actor.character_index
- end
- end
- #shit
- def make_action
- end
- def normal_attack_right
- end
- def weapon_range_attack
- end
- def range_attack_right
- end
- def normal_attack_left
- end
- def range_attack_left
- end
- def skill_attack_normal
- end
- def skill_attack_range
- end
- def skill_attack_all
- end
- def skill_explode_range
- end
- def skill_recover
- end
- def auto_recovery
- end
- #@@
- def update_movement
- return if $game_map.interpreter.running?
- return if moving?
- return if self.freeze or (self.anime_attack/2) > 0
- if $game_player.dash? and self.target == $game_player
- @move_speed = 5
- else
- @move_speed = self.original_move_speed
- end
- #shit
- self.target = $game_player
- away = false
- for monster in $game_monsters.compact
- next unless in_range?($game_player, monster, 3)
- next if monster.actor.dead?
- away = true
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next unless in_range?($game_player, event, 3)
- next if event.actor.dead? or event.object
- away = true
- end
- if away == false
- move_toward(self.target)
- else
- move_away_from(self.target)
- end
- #@@
- end
- def perform_transfer(map_id, x, y, dir)
- @map_id = map_id
- set_direction(dir)
- moveto(x, y)
- move_random
- self.target = $game_player
- self.lock_target = false
- end
- def screen_z
- return $game_player.screen_z-1
- end
- def in_vehicle?
- return $game_player.in_vehicle?
- end
- end
- #------------------------------------------------------------------------------
- # Game Monster
- #------------------------------------------------------------------------------
- class Game_Monster < Game_Character
- attr_reader :respawn
- attr_accessor :draw
- attr_accessor :destroy
- def initialize(id, enemy_id, troop_id, area)
- super()
- @id = id
- @enemy_id = enemy_id
- @troop_id = troop_id
- @area = area
- setup_monster
- loop do
- set_start_position
- break if $game_map.passable?(@x_pos, @y_pos) and !empty_area?
- end
- moveto(@x_pos, @y_pos)
- @move_type = self.actor.move_route
- @move_speed = self.actor.move_speed
- @draw = false
- refresh
- end
- def setup_monster
- self.actor = Game_Enemy.new(0, @enemy_id)
- self.actor.piece = self
- @respawn = self.actor.respawn
- self.actor.recover_all
- @draw = false
- @destroy = false
- @killed = false
- @opacity = 255
- @blend_type = 0
- refresh
- end
- def set_start_position
- if @area != nil
- x = []
- for i in (@area.rect.x)...(@area.rect.x+@area.rect.width)
- x << i
- end
- y = []
- for i in (@area.rect.y)...(@area.rect.y+@area.rect.height)
- y << i
- end
- @x_pos = x[rand(x.size)]
- @y_pos = y[rand(y.size)]
- else
- @x_pos = rand($game_map.width)
- @y_pos = rand($game_map.height)
- end
- end
- def empty_area?
- x = []; y = []
- for area in $data_areas.values
- next unless area.map_id == $game_map.map_id
- next unless area.name == "EMPTY"
- x = (area.rect.x)...(area.rect.x+area.rect.width)
- y = (area.rect.y)...(area.rect.y+area.rect.height)
- end
- return true if x.include?(@x_pos) and y.include?(@y_pos)
- return false
- end
- def refresh
- @character_name = self.actor.character_name
- @character_index = self.actor.character_index
- end
- def update
- super
- if !self.actor.dead?
- update_attack
- else
- update_dying
- end
- end
- def update_attack
- return if $game_map.interpreter.running?
- return if $game_player.in_vehicle?
- for action in self.actor.enemy.actions
- next unless self.actor.conditions_met?(action)
- next unless rand(11) < action.rating
- next if self.weapon1_attack_time > 0
- case action.kind
- when 0
- case action.basic
- when 0
- attack_normal
- when 1
- self.actor.defending = true
- end
- when 1
- self.assigned_skill = $data_skills[action.skill_id]
- case self.assigned_skill.scope
- when 1...7
- if self.assigned_skill.ranged?
- if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
- skill_attack_range
- elsif action.rating == 10
- skill_attack_range
- else
- end
- elsif self.assigned_skill.explosive?
- if in_direction?(self, $game_player) and in_range?(self, $game_player, self.assigned_skill.range)
- skill_explode_range
- elsif action.rating == 10
- skill_explode_range
- else
- end
- else
- skill_attack_normal
- end
- when 7...12
- skill_recover
- end
- end
- end
- end
- def attack_normal
- return if $game_player.actor.nil?
- return unless in_front?(self, $game_player)
- self.anime_attack = 20
- $game_player.animation_id = self.actor.atk_animation_id
- $game_player.actor.attack_effect(self.actor)
- $game_player.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- def skill_attack_normal
- return if self.actor.mp < self.assigned_skill.mp_cost
- return if $game_player.actor.nil?
- return unless in_front?(self, $game_player)
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_player.animation_id = self.assigned_skill.animation_id
- $game_player.actor.skill_effect(self.actor, self.assigned_skill)
- $game_player.jump(0,0)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- def skill_attack_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 3))
- self.weapon1_attack_time = self.assigned_skill.delay
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- end
- def skill_explode_range
- return unless self.actor.mp >= self.assigned_skill.mp_cost
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- $game_range.push(Game_Range.new(self, self.assigned_skill.graphic, self.assigned_skill.index, self.assigned_skill.move_speed, self.assigned_skill.range, 4))
- self.weapon1_attack_time = self.assigned_skill.delay
- RPG::SE.new(self.assigned_skill.shot_se).play if self.assigned_skill.shot_se != nil
- end
- def skill_recover
- if self.actor.mp >= self.assigned_skill.mp_cost and self.actor.hp <= (self.actor.maxhp*25/100)
- self.actor.mp -= self.actor.calc_mp_cost(self.assigned_skill)
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- @animation_id = self.assigned_skill.animation_id
- self.actor.skill_effect(self.actor, self.assigned_skill)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- for event in $game_map.events.values
- if event.in_battle and in_range?(self, event, 3)
- if self.actor.mp >= self.assigned_skill.mp_cost and event.actor.hp <= (event.actor.maxhp*25/100)
- self.actor.mp -= self.assigned_skill.mp_cost
- $game_temp.common_event_id = self.assigned_skill.common_event_id if self.assigned_skill.common_event_id > 0
- event.animation_id = self.assigned_skill.animation_id
- event.actor.skill_effect(self.actor, self.assigned_skill)
- self.weapon1_attack_time = self.actor.attack_speed
- end
- end
- end
- end
- def update_dying
- @blend_type = 2
- @opacity -= 5
- get_rewards unless @killed
- if @opacity <= 0 and !@destroy
- $game_player.hits = 0
- @destroy = true
- end
- if @destroy and @respawn > 0
- @respawn -= 1
- setup_monster if @respawn <= 0
- end
- end
- def get_rewards
- if $Requiem_ABS.auto_exp_e_gold
- exp = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
- self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_exp_rate / 100
- else
- exp = self.actor.exp
- end
- if $Requiem_ABS.divide_exp
- x = (exp/$game_party.members.size)
- for i in $game_party.members
- i.gain_exp(x, true)
- end
- else
- self.target.actor.gain_exp(exp, true)
- end
- droped_items = []
- for i in [self.actor.drop_item1, self.actor.drop_item2]
- next if i.kind <= 0
- next if rand(i.denominator) != 0
- if i.kind == 1
- droped_items.push($data_items[i.item_id])
- elsif i.kind == 2
- droped_items.push($data_weapons[i.weapon_id])
- elsif i.kind == 3
- droped_items.push($data_armors[i.armor_id])
- end
- end
- for t in droped_items.compact
- $game_drop.push(Game_Drop.new(self, t.icon_index, t , 0))
- end
- if $Requiem_ABS.auto_exp_e_gold
- gold = (self.actor.maxhp+self.actor.maxmp+self.actor.atk+self.actor.def+self.actor.spi+
- self.actor.agi+self.actor.hit+self.actor.eva) * $Requiem_ABS.auto_gold_rate / 100
- else
- gold = self.actor.gold
- end
- if gold > 0 and rand(100) <= $Requiem_ABS.gold_drop_rate
- $game_drop.push(Game_Drop.new(self, $Requiem_ABS.gold_drop_icon_index, nil, gold))
- end
- @animation_id = self.actor.die_animation_id if self.actor.die_animation_id > 0
- if self.actor.die_se != nil
- RPG::SE.new(self.actor.die_se).play
- else
- Sound.play_enemy_collapse
- end
- $game_variables[$Requiem_ABS.battle_area_variable] += 1 if $Requiem_ABS.battle_area_variable > 0
- @killed = true
- end
- def update_self_movement
- return if moving?
- return if self.actor.dead?
- return if self.freeze or (self.anime_attack/2) > 0
- return unless @stop_count > 30 * (5 - @move_frequency)
- if in_range?(self, $game_player, self.actor.follow_range) and !self.lock_target
- self.target = $game_player
- self.lock_target = true
- end
- if self.target != nil and in_range?(self, self.target, self.actor.follow_range)
- move_type_toward(self.target)
- else
- case @move_type
- when 1
- move_type_random
- when 2
- move_type_toward_player
- when 3
- move_type_custom
- end
- end
- end
- end
- #------------------------------------------------------------------------------
- # Game Range
- #------------------------------------------------------------------------------
- class Game_Range < Game_Character
- attr_accessor :draw
- attr_accessor :destroy
- def initialize(parent, chara_name="", chara_index=0, speed=4, range=5, type=3)
- super()
- @parent = parent
- @character_name = chara_name
- @character_index = chara_index
- @move_speed = speed
- @range = range
- @type = type
- @step = 0
- @destroy = false
- @draw = false
- @moving = false
- @direction = @parent.direction
- moveto(@parent.x, @parent.y)
- case @type
- when 1
- @item = @parent.actor.equips[0]
- when 2
- if @parent.actor.two_hands_legal?
- @item = @parent.actor.equips[0]
- else
- @item = @parent.actor.equips[1]
- end
- when 3...5
- @item = @parent.assigned_skill
- when 5...7
- @item = @parent.assigned_item
- end
- end
- def update
- super
- return if @destroy
- @destroy = (@step > @range)
- return unless stopping?
- case @item.path
- when "Line"
- unless @moving
- @move_route = RPG::MoveRoute.new
- for i in 0...@range
- @move_route.list.insert(0, RPG::MoveCommand.new(12))
- end
- @moving = true
- end
- when "Boom"
- unless @moving
- @move_route = RPG::MoveRoute.new
- @move_route.list = [
- RPG::MoveCommand.new(12),
- RPG::MoveCommand.new(12),
- RPG::MoveCommand.new(12),
- RPG::MoveCommand.new(12),
- RPG::MoveCommand.new(12),
- RPG::MoveCommand.new(13),
- RPG::MoveCommand.new(13),
- RPG::MoveCommand.new(13),
- RPG::MoveCommand.new(13),
- RPG::MoveCommand.new(13),
- RPG::MoveCommand.new()]
- @range = @move_route.list.size-1
- @moving = true
- end
- when "Circle"
- unless @moving
- $game_player.anime_attack = 70
- @move_route = RPG::MoveRoute.new
- @move_route.list = [
- RPG::MoveCommand.new(37),
- RPG::MoveCommand.new(4),
- RPG::MoveCommand.new(2),
- RPG::MoveCommand.new(1),
- RPG::MoveCommand.new(1),
- RPG::MoveCommand.new(3),
- RPG::MoveCommand.new(3),
- RPG::MoveCommand.new(4),
- RPG::MoveCommand.new(4),
- RPG::MoveCommand.new(2),
- RPG::MoveCommand.new()]
- @range = @move_route.list.size-1
- @moving = true
- end
- when "Jump"
- unless @moving
- @move_route = RPG::MoveRoute.new
- case @parent.direction
- when 2
- dir = 0, 3
- when 4
- dir = -3, 0
- when 6
- dir = 3, 0
- when 8
- dir = 0, -3
- end
- @move_route.list = [
- RPG::MoveCommand.new(14, [dir[0], dir[1]]),
- RPG::MoveCommand.new()]
- @moving = true
- end
- when "Random"
- unless @moving
- @move_route = RPG::MoveRoute.new
- for i in 0...@range
- @move_route.list.insert(0, RPG::MoveCommand.new(9))
- end
- @moving = true
- end
- end
- @move_route.skippable = true
- move_type_custom
- x = (@direction == 4 ? -1 : @direction == 6 ? 1 : 0)
- y = (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
- check_event_trigger_touch(@x+x, @y+y) unless jumping?
- @step += 1
- end
- def check_event_trigger_touch(x, y)
- return if @destroy
- if @parent.is_a?(Game_Event) or @parent.is_a?(Game_Monster)
- case @type
- when 3
- for ally in $game_allies.compact
- hurt_hero_skill(ally) if ally.pos?(x, y)
- end
- hurt_hero_skill($game_player) if $game_player.pos?(x, y)
- when 4
- for ally in $game_allies.compact
- hurt_hero_skill_explode if ally.pos?(x, y)
- end
- hurt_hero_skill_explode if $game_player.pos?(x, y)
- end
- return
- end
- for monster in $game_monsters.compact
- next unless monster.pos?(x, y)
- case @type
- when 1
- hurt_monster_weapon_right(monster)
- when 2
- hurt_monster_weapon_left(monster)
- when 3
- hurt_monster_skill(monster)
- when 4
- hurt_enemy_skill_explode
- when 5
- hurt_monster_item(monster)
- when 6
- hurt_enemy_item_explode
- end
- end
- for event in $game_map.events.values
- next unless event.in_battle and event.pos?(x, y)
- case @type
- when 1
- hurt_enemy_weapon_right(event)
- when 2
- hurt_enemy_weapon_left(event)
- when 3
- hurt_enemy_skill(event)
- when 4
- hurt_enemy_skill_explode
- when 5
- hurt_enemy_item(event)
- when 6
- hurt_enemy_item_explode
- end
- end
- end
- def hurt_hero_skill(hero)
- return if self.target == hero
- return if hero.actor.dead?
- self.target = hero
- hero.animation_id = @parent.assigned_skill.animation_id
- hero.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- @destroy = true
- end
- def hurt_hero_skill_explode
- for ally in $game_allies.compact
- next if self.target == ally
- next unless in_range?(self, ally, @parent.assigned_skill.range)
- next if ally.actor.dead?
- self.target = ally
- ally.animation_id = @parent.assigned_skill.animation_id
- ally.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- end
- if in_range?(self, $game_player, @parent.assigned_skill.range) and
- self.target != $game_player and !$game_player.actor.dead?
- self.target = $game_player
- $game_player.animation_id = @parent.assigned_skill.animation_id
- $game_player.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- end
- @destroy = true
- end
- def hurt_enemy_weapon_right(enemy)
- return if self.target == enemy
- return if enemy.actor.dead? or enemy.object
- if @parent.actor.weapons[0].ammo1 != nil
- enemy.animation_id = @parent.actor.equips[0].ammo1.animation_id
- else
- enemy.animation_id = @parent.actor.atk_animation_id
- end
- return if enemy.kill_with_weapon > 0 and enemy.kill_with_weapon != @parent.actor.weapon_id or
- enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
- self.target = enemy
- enemy.actor.attack_effect(@parent.actor)
- enemy.jump(0,0) unless enemy.puzzle
- enemy.target = @parent
- @destroy = true
- end
- def hurt_enemy_weapon_left(enemy)
- return if self.target == enemy
- return if enemy.actor.dead? or enemy.object
- if @parent.actor.two_swords_style
- @weapon = @parent.actor.weapons[1]
- else
- @weapon = @parent.actor.weapons[0]
- end
- if @weapon.ammo2 != nil
- enemy.animation_id = @weapon.ammo2.animation_id
- else
- enemy.animation_id = @parent.actor.atk_animation_id2
- end
- return if enemy.kill_with_weapon > 0 and enemy.kill_with_weapon != @weapon.id or
- enemy.kill_with_skill > 0 or enemy.kill_with_item > 0
- self.target = enemy
- enemy.actor.attack_effect(@parent.actor)
- enemy.jump(0,0) unless enemy.puzzle
- enemy.target = @parent
- @destroy = true
- end
- def hurt_enemy_skill(enemy)
- return if self.target == enemy
- return if enemy.actor.dead? or enemy.object
- enemy.animation_id = @parent.assigned_skill.animation_id
- return if enemy.kill_with_weapon > 0 or enemy.kill_with_item > 0 or
- enemy.kill_with_skill > 0 and enemy.kill_with_skill != @parent.assigned_skill.id
- self.target = enemy
- enemy.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- enemy.jump(0,0) unless enemy.puzzle
- enemy.target = @parent
- @destroy = true
- end
- def hurt_enemy_item(enemy)
- return if self.target == enemy
- return if enemy.actor.dead? or enemy.object
- enemy.animation_id = @parent.assigned_item.animation_id
- return if enemy.kill_with_weapon > 0 or enemy.kill_with_skill > 0 or
- enemy.kill_with_item > 0 and enemy.kill_with_item != @parent.assigned_item.id
- self.target = enemy
- enemy.actor.item_effect(@parent.actor, @parent.assigned_item)
- enemy.jump(0,0) unless enemy.puzzle
- enemy.target = @parent
- @destroy = true
- end
- def hurt_enemy_skill_explode
- for monster in $game_monsters.compact
- next if self.target == monster
- next if monster.actor.dead?
- next unless in_range?(self, monster, @parent.assigned_skill.area)
- self.target = monster
- monster.animation_id = @parent.assigned_skill.animation_id
- monster.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next if self.target == event
- next if event.actor.dead? or event.object
- next unless in_range?(self, event, @parent.assigned_skill.area)
- self.target = event
- event.animation_id = @parent.assigned_skill.animation_id
- next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
- event.kill_with_skill > 0 and event.kill_with_skill != @parent.assigned_skill.id
- event.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- event.jump(0,0) unless event.puzzle
- event.target = @parent
- end
- @destroy = true
- end
- def hurt_enemy_item_explode
- for monster in $game_monsters.compact
- next if self.target == monster
- next if monster.actor.dead?
- next unless in_range?(self, monster, @parent.assigned_item.area)
- self.target = monster
- monster.animation_id = @parent.assigned_item.animation_id
- monster.actor.item_effect(@parent.actor, @parent.assigned_item)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- for event in $game_map.events.values
- next unless event.in_battle
- next if self.target == event
- next if event.actor.dead? or event.object
- next unless in_range?(self, event, @parent.assigned_item.area)
- self.target = event
- event.animation_id = @parent.assigned_item.animation_id
- next if event.kill_with_weapon > 0 or event.kill_with_item > 0 or
- event.kill_with_skill > 0 and event.kill_with_skill != @parent.assigned_item.id
- event.actor.item_effect(@parent.actor, @parent.assigned_item)
- event.jump(0,0) unless event.puzzle
- event.target = @parent
- end
- @destroy = true
- end
- def hurt_monster_weapon_right(monster)
- return if self.target == monster
- return if monster.actor.dead?
- self.target = monster
- if @parent.actor.weapons[0].ammo1 != nil
- monster.animation_id = @parent.actor.equips[0].ammo1.animation_id
- else
- monster.animation_id = @parent.actor.atk_animation_id
- end
- monster.actor.attack_effect(@parent.actor)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- def hurt_monster_weapon_left(monster)
- return if self.target == monster
- return if monster.actor.dead?
- self.target = monster
- if @parent.actor.two_swords_style
- @weapon = @parent.actor.weapons[1]
- else
- @weapon = @parent.actor.weapons[0]
- end
- if @weapon.ammo2 != nil
- monster.animation_id = @weapon.ammo2.animation_id
- else
- monster.animation_id = @parent.actor.atk_animation_id2
- end
- monster.actor.attack_effect(@parent.actor)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- def hurt_monster_skill(monster)
- return if self.target == monster
- return if monster.actor.dead?
- self.target = monster
- monster.animation_id = @parent.assigned_skill.animation_id
- monster.actor.skill_effect(@parent.actor, @parent.assigned_skill)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- def hurt_monster_item(monster)
- return if self.target == monster
- return if monster.actor.dead?
- self.target = monster
- monster.animation_id = @parent.assigned_item.animation_id
- monster.actor.item_effect(@parent.actor, @parent.assigned_item)
- monster.jump(0,0)
- monster.target = @parent
- @destroy = true
- end
- def map_passable?(x, y)
- return $game_map.range_passable?(x, y)
- end
- end
- #------------------------------------------------------------------------------
- # Game Bomb
- #------------------------------------------------------------------------------
- class Game_Bomb < Game_Character
- attr_accessor :draw
- attr_accessor :destroy
- attr_accessor :character_name
- attr_accessor :character_index
- def initialize(parent, item)
- super()
- @parent = parent
- @item = item
- @character_name = "IconSet"
- @character_index = @item.icon_index
- @area = @item.area
- @time = @item.delay
- @destroy = false
- @draw = false
- self.priority_type = 2
- jump(0, 0)
- case @parent.direction
- when 2
- moveto(@parent.x, @parent.y+1)
- when 4
- moveto(@parent.x-1, @parent.y)
- when 6
- moveto(@parent.x+1, @parent.y)
- when 8
- moveto(@parent.x, @parent.y-1)
- end
- RPG::SE.new($Requiem_ABS.drop_se[1]).play if $Requiem_ABS.drop_se[1] != ""
- move_random if !$game_map.passable?(@x, @y) or $game_map.events_xy(@x, @y) != []
- end
- def update
- super
- return if @destroy
- if @item.shot_se != nil and Graphics.frame_count % 60 <= 0
- RPG::SE.new(@item.shot_se).play
- end
- @time -= 1 if @time > 0
- explode if @time <= 0
- end
- def explode
- @animation_id = @item.animation_id
- if in_range?(self, $game_player, @area)
- $game_player.actor.item_effect(@parent.actor, @item)
- $game_player.jump(0, 0)
- end
- for monster in $game_monsters.compact
- next unless in_range?(self, monster, @area)
- monster.actor.item_effect(@parent.actor, @item)
- monster.jump(0, 0)
- end
- for event in $game_map.events.values
- next unless event.in_battle and in_range?(self, event, @area)
- event.actor.item_effect(@parent.actor, @item)
- event.jump(0, 0) unless event.puzzle
- end
- for ally in $game_allies.compact
- next if ally.actor.dead?
- next unless in_range?(self, ally, @area)
- ally.actor.item_effect(@parent.actor, @item)
- ally.jump(0, 0)
- end
- @destroy = true
- end
- def screen_z
- return $game_player.screen_z-2
- end
- end
- #------------------------------------------------------------------------------
- # Game Drop
- #------------------------------------------------------------------------------
- class Game_Drop < Game_Character
- attr_accessor :draw
- attr_accessor :destroy
- attr_accessor :character_name
- attr_accessor :character_index
- def initialize(parent, character_index=0, item=nil, gold=0)
- super()
- @character_name = "IconSet"
- @character_index = character_index
- @item = item
- @gold = gold
- @drop_time = $Requiem_ABS.drop_duration_time
- moveto(parent.x, parent.y)
- RPG::SE.new($Requiem_ABS.drop_se[0]).play if $Requiem_ABS.drop_se[0] != "" and @gold > 0
- RPG::SE.new($Requiem_ABS.drop_se[1]).play if $Requiem_ABS.drop_se[1] != "" and @items != nil
- @destroy = false
- @draw = false
- jump(0,0)
- move_random if !moving?
- end
- def update
- super
- return if @destroy
- @drop_time -= 1 if @drop_time > 0
- @destroy = (@drop_time <= 0)
- return unless Input.trigger?(Input::C) and in_front?($game_player, self)
- get_reward
- end
- def get_reward
- Sound.play_decision
- case @item
- when RPG::Item
- $game_party.gain_item($data_items[@item.id],1)
- $game_player.reward = $data_items[@item.id].name
- when RPG::Weapon
- $game_party.gain_item($data_weapons[@item.id],1)
- $game_player.reward = $data_weapons[@item.id].name
- when RPG::Armor
- $game_party.gain_item($data_armors[@item.id],1)
- $game_player.reward = $data_armors[@item.id].name
- end
- if @gold > 0
- $game_party.gain_gold(@gold)
- $game_player.reward = "#{Vocab.gold} #{@gold}"
- end
- @destroy = true
- end
- def screen_z
- return $game_player.screen_z-2
- end
- end
- #------------------------------------------------------------------------------
- # Sprite Base
- #------------------------------------------------------------------------------
- class Sprite_Base
- attr_reader :animation_duration
- alias requiem_abs_spbase_initialize initialize
- alias requiem_abs_spbase_update update
- alias requiem_abs_spbase_dispose dispose
- def initialize(viewport = nil)
- requiem_abs_spbase_initialize(viewport)
- @_damage_duration = 0
- @_hit_duration = 0
- @_reward_duration = 0
- end
- def update
- requiem_abs_spbase_update
- update_show_dmg
- update_show_hit
- update_show_reward
- 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] / $Requiem_ABS.animations_divide
- sprite.y = @animation_oy + cell_data[i, 2] / $Requiem_ABS.animations_divide
- sprite.angle = (360 - cell_data[i, 4])
- sprite.mirror = (cell_data[i, 5] == 0)
- else
- sprite.x = @animation_ox + cell_data[i, 1] / $Requiem_ABS.animations_divide
- sprite.y = @animation_oy + cell_data[i, 2] / $Requiem_ABS.animations_divide
- sprite.angle = cell_data[i, 4]
- sprite.mirror = (cell_data[i, 5] == 1)
- end
- sprite.z = self.z + 300 + i
- sprite.ox = 96
- sprite.oy = 96
- sprite.zoom_x = cell_data[i, 3] / (100.0 * $Requiem_ABS.animations_divide)
- sprite.zoom_y = cell_data[i, 3] / (100.0 * $Requiem_ABS.animations_divide)
- sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
- sprite.blend_type = cell_data[i, 7]
- end
- end
- def update_show_dmg
- if @_damage_duration > 0
- @_damage_duration -=1
- @_damage_sprite.y -= 1
- @_damage_sprite.x = self.x
- elsif @_damage_duration <= 0 and @_damage_sprite != nil and !@_damage_sprite.disposed?
- @_damage_sprite.y -= 1
- @_damage_sprite.opacity -= 5
- dispose_damage if @_damage_sprite.opacity <= 0
- end
- if @character.actor != nil and @character.actor.damage != 0
- return if @character.is_a?(Game_Event) and @character.puzzle
- damage(@character.actor.damage, @character.actor.critical, @character.actor.combo, @character.actor.reflect)
- @character.actor.damage = 0
- @character.actor.critical = @character.actor.combo = @character.actor.reflect = false
- end
- end
- def update_show_hit
- if @_hit_duration > 0
- @_hit_duration -=1
- elsif @_hit_duration <= 0 and @_hit_sprite != nil and !@_hit_sprite.disposed?
- @_hit_sprite.opacity -= 5
- dispose_hit if @_hit_sprite.opacity <= 0
- end
- if @character.is_a?(Game_Player) and @character.hit != nil
- hit(@character.hit)
- @character.hit = nil
- end
- end
- def update_show_reward
- if @_reward_duration > 0
- @_reward_duration -= 1
- elsif @_reward_duration <= 0 and @_reward_sprite != nil and !@_reward_sprite.disposed?
- @_reward_sprite.opacity -= 5
- dispose_reward if @_reward_sprite.opacity <= 0
- end
- if $game_player.reward != nil and $Requiem_ABS.show_reward
- reward($game_player.reward)
- $game_player.reward = nil
- end
- end
- def update_show_state_ani
- return if @character.actor.nil?
- for state in @character.actor.states
- next if state.nil? or state.animation_id <= 0
- if @character.ani_time <= 0
- @character.animation_id = state.animation_id
- @character.ani_time = $data_animations[@character.animation_id].frame_max * 4 + 1
- end
- end
- end
- def damage(value, critical, combo, reflect)
- dispose_damage
- damage_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
- bitmap = Bitmap.new(160, ($Requiem_ABS.damage_properties["Dano"][1]*2)+10)
- bitmap.font.name = $Requiem_ABS.damage_properties["Dano"][0]
- bitmap.font.size = $Requiem_ABS.damage_properties["Dano"][1]
- bitmap.font.bold = $Requiem_ABS.damage_properties["Dano"][2]
- bitmap.font.italic = $Requiem_ABS.damage_properties["Dano"][3]
- bitmap.font.shadow = false
- if value.is_a?(Numeric) and value <= 0
- color = $Requiem_ABS.damage_properties["Colors"][1]
- else
- color = $Requiem_ABS.damage_properties["Colors"][0]
- end
- bitmap.draw_outlined_text(0, bitmap.font.size+5, bitmap.width, bitmap.font.size, damage_string, 1, color)
- if reflect
- color = $Requiem_ABS.damage_properties["Colors"][5]
- bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, $Requiem_ABS.damage_properties["Texts"][6], 1, color)
- elsif combo
- color = $Requiem_ABS.damage_properties["Colors"][3]
- bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size,$Requiem_ABS.damage_properties["Texts"][2], 1, color)
- elsif critical
- color = $Requiem_ABS.damage_properties["Colors"][2]
- bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, $Requiem_ABS.damage_properties["Texts"][1], 1, color)
- end
- @_damage_sprite = Sprite.new(self.viewport)
- @_damage_sprite.bitmap = bitmap
- @_damage_sprite.ox = bitmap.width/2
- @_damage_sprite.oy = bitmap.height*2
- @_damage_sprite.x = self.x
- @_damage_sprite.y = self.y
- @_damage_sprite.z = 999999
- @_damage_duration = 30
- end
- def hit(value)
- dispose_hit
- hit_string = (value.is_a?(Numeric) ? value.abs.to_s : value.to_s)
- bitmap = Bitmap.new(160, $Requiem_ABS.damage_properties["Golpes"][1])
- bitmap.font.name = $Requiem_ABS.damage_properties["Golpes"][0]
- bitmap.font.size = $Requiem_ABS.damage_properties["Golpes"][1]
- bitmap.font.bold = $Requiem_ABS.damage_properties["Golpes"][2]
- bitmap.font.italic = $Requiem_ABS.damage_properties["Golpes"][3]
- bitmap.font.shadow = false
- color = $Requiem_ABS.damage_properties["Colors"][4]
- bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size,"#{hit_string}" "#{$Requiem_ABS.damage_properties["Texts"][5]}", 2, color)
- @_hit_sprite = Sprite.new(self.viewport)
- @_hit_sprite.bitmap = bitmap
- @_hit_sprite.x = Graphics.width-bitmap.width-10
- @_hit_sprite.y = (Graphics.height/2)-bitmap.font.size
- @_hit_sprite.z = 999999
- @_hit_duration = 60
- end
- def reward(reward)
- dispose_reward
- bitmap = Bitmap.new(200, $Requiem_ABS.damage_properties["Recompensa"][1])
- bitmap.font.name = $Requiem_ABS.damage_properties["Recompensa"][0]
- bitmap.font.size = $Requiem_ABS.damage_properties["Recompensa"][1]
- bitmap.font.bold = $Requiem_ABS.damage_properties["Recompensa"][2]
- bitmap.font.italic = $Requiem_ABS.damage_properties["Recompensa"][3]
- bitmap.font.shadow = false
- color = $Requiem_ABS.damage_properties["Colors"][0]
- bitmap.draw_outlined_text(0, 0, bitmap.width, bitmap.font.size, reward, 0, color)
- @_reward_sprite = Sprite.new(self.viewport)
- @_reward_sprite.bitmap = bitmap
- @_reward_sprite.x = 10
- @_reward_sprite.y = (Graphics.height/2)-bitmap.font.size
- @_reward_sprite.z = 999999
- @_reward_duration = 300
- end
- def dispose
- requiem_abs_spbase_dispose
- dispose_damage
- dispose_hit
- dispose_reward
- end
- def dispose_damage
- return if @_damage_sprite.nil?
- @_damage_sprite.bitmap.dispose
- @_damage_sprite.dispose
- @_damage_sprite = nil
- end
- def dispose_hit
- return if @_hit_sprite.nil?
- @_hit_sprite.bitmap.dispose
- @_hit_sprite.dispose
- @_hit_sprite = nil
- end
- def dispose_reward
- return if @_reward_sprite.nil?
- @_reward_sprite.bitmap.dispose
- @_reward_sprite.dispose
- @_reward_sprite = nil
- end
- end
- #------------------------------------------------------------------------------
- # Sprite Drop
- #------------------------------------------------------------------------------
- class Sprite_Drop < Sprite_Base
- attr_accessor :character
- def initialize(viewport, character=nil)
- super(viewport)
- @character = character
- update
- end
- def update
- super
- update_bitmap
- self.x = @character.screen_x
- self.y = @character.screen_y
- self.z = @character.screen_z
- self.opacity = @character.opacity
- self.blend_type = @character.blend_type
- self.bush_depth = @character.bush_depth
- if @character.animation_id != 0
- start_animation($data_animations[@character.animation_id])
- @character.animation_id = 0
- end
- end
- def update_bitmap
- return if @character_name == @character.character_name
- @character_name = @character.character_name
- self.bitmap = Cache.system(@character_name)
- self.ox = 12
- self.oy = 24
- sx = @character.character_index % 16 * 24
- sy = @character.character_index / 16 * 24
- self.src_rect.set(sx, sy, 24, 24)
- end
- end
- #------------------------------------------------------------------------------
- # Sprite Weapon
- #------------------------------------------------------------------------------
- class Sprite_Weapon < Sprite_Base
- attr_accessor :character
- def initialize(viewport, character=nil)
- super(viewport)
- @character = character
- self.visible = false
- create_bitmap
- update
- end
- def update
- super
- return unless $Requiem_ABS.allow_weapons_graphics
- return if @character.actor.nil?
- return if @character.is_a?(Game_Ally) and @character.map_id != $game_map.map_id
- self.visible = (@character.anime_attack > 0)
- update_src_rect
- update_movement
- end
- def create_bitmap
- self.bitmap = Cache.system("Iconset")
- self.ox = 12
- self.oy = 24
- self.zoom_x = 0.80
- self.zoom_y = 0.80
- end
- def update_src_rect
- sx = weapon_index % 16 * 24
- sy = weapon_index / 16 * 24
- self.src_rect.set(sx, sy, 24, 24)
- end
- def update_movement
- case @character.direction
- when 2
- self.x = @character.screen_x-6
- self.z = @character.screen_z+2
- self.mirror = false
- change_angle(180, 135, 90)
- when 4
- self.x = @character.screen_x-10
- self.z = @character.screen_z-1
- self.mirror = false
- change_angle(-45, 0, 45)
- when 6
- self.x = @character.screen_x+10
- self.z = @character.screen_z+2
- self.mirror = true
- change_angle(45, 0, -45)
- when 8
- self.x = @character.screen_x+10
- self.z = @character.screen_z-1
- self.mirror = true
- change_angle(45, 0, -45)
- end
- self.y = @character.screen_y-4
- self.opacity = @character.opacity
- self.blend_type = @character.blend_type
- self.bush_depth = @character.bush_depth
- end
- def change_angle(a, b, c)
- if @character.anime_attack >= 20
- self.angle = a
- elsif @character.anime_attack >= 15
- self.angle = b
- elsif @character.anime_attack >= 10
- self.angle = c
- end
- end
- def weapon_index
- return 0 if @character.actor.nil?
- if @character.actor.is_a?(Game_Actor) and @character.right_attack_on and @character.actor.equips[0] != nil
- return @character.actor.equips[0].icon_index
- elsif @character.actor.is_a?(Game_Actor) and @character.left_attack_on
- if @character.actor.two_swords_style and @character.actor.equips[1] != nil
- return @character.actor.equips[1].icon_index
- elsif @character.actor.two_hands_legal? and @character.actor.equips[0] != nil and @character.actor.equips[0].ranged?
- return @character.actor.equips[0].icon_index
- end
- elsif @character.actor.is_a?(Game_Enemy) and @character.actor.weapon_icon > 0
- return @character.actor.weapon_icon
- end
- return 0
- end
- end
- #------------------------------------------------------------------------------
- # Sprite Shield
- #------------------------------------------------------------------------------
- class Sprite_Shield < Sprite_Base
- attr_accessor :character
- def initialize(viewport, character = nil)
- super(viewport)
- @character = character
- self.visible = false
- create_bitmap
- update
- end
- def update
- super
- return unless $Requiem_ABS.allow_shields_graphics
- return if @character.actor.nil?
- return if @character.is_a?(Game_Ally) and @character.map_id != $game_map.map_id
- self.visible = @character.actor.defending
- update_src_rect
- update_movement
- moving_with_shield
- end
- def create_bitmap
- self.bitmap = Cache.system("Iconset")
- self.ox = 12
- self.oy = 24
- self.zoom_x = 0.80
- self.zoom_y = 0.80
- end
- def update_src_rect
- sx = shield_index % 16 * 24
- sy = shield_index / 16 * 24
- self.src_rect.set(sx, sy, 24, 24)
- end
- def 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
- self.opacity = @character.opacity
- self.blend_type = @character.blend_type
- self.bush_depth = @character.bush_depth
- end
- def moving_with_shield
- if @character.moving?
- self.wave_amp = 1
- self.wave_length = 1
- self.wave_speed = 6
- else
- self.wave_amp = 0
- end
- end
- def shield_index
- return 0 if @character.actor.nil?
- if @character.actor.is_a?(Game_Actor) and !@character.actor.two_swords_style and @character.actor.armor1_id > 0
- return @character.actor.armors[0].icon_index
- elsif @character.actor.is_a?(Game_Enemy) and @character.actor.shield_icon > 0
- return @character.actor.shield_icon
- end
- return 0
- end
- end
- #------------------------------------------------------------------------------
- # Spriteset Map
- #------------------------------------------------------------------------------
- class Spriteset_Map
- alias requiem_abs_sp_map_create_characters create_characters
- alias requiem_abs_sp_map_dispose_characters dispose_characters
- def create_characters
- @allies_sprites = []
- for ally in $game_allies.compact
- @allies_sprites.push(Sprite_Character.new(@viewport1, ally))
- end
- @range_sprites = []
- for range in $game_range.compact
- next unless $game_map.in_range?(range)
- @range_sprites.push(Sprite_Character.new(@viewport1, range))
- end
- @drop_sprites = []
- for drop in $game_drop.compact
- next unless $game_map.in_range?(drop)
- @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
- end
- for bomb in $game_bomb.compact
- next unless $game_map.in_range?(bomb)
- @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
- end
- @weapon_sprites = []
- @shield_sprites = []
- @weapon_sprites.push(Sprite_Weapon.new(@viewport1, $game_player))
- @shield_sprites.push(Sprite_Shield.new(@viewport1, $game_player))
- for ally in $game_allies.compact
- @weapon_sprites.push(Sprite_Weapon.new(@viewport1, ally))
- @shield_sprites.push(Sprite_Shield.new(@viewport1, ally))
- end
- for i in $game_map.events.keys.sort
- @weapon_sprites.push(Sprite_Weapon.new(@viewport1, $game_map.events[i]))
- @shield_sprites.push(Sprite_Shield.new(@viewport1, $game_map.events[i]))
- end
- @monsters_sprites = []
- for monster in $game_monsters.compact
- @monsters_sprites.push(Sprite_Character.new(@viewport1, monster))
- @weapon_sprites.push(Sprite_Weapon.new(@viewport1, monster))
- @shield_sprites.push(Sprite_Shield.new(@viewport1, monster))
- end
- requiem_abs_sp_map_create_characters
- end
- def update_characters
- for sprite in @character_sprites
- if sprite.character.is_a?(Game_Event)
- sprite.update if $game_map.in_range?(sprite.character)
- else
- sprite.update
- end
- end
- for ally in @allies_sprites.compact
- if ally.character.destroy and !ally.disposed?
- ally.dispose
- $game_allies.delete(ally.character)
- @allies_sprites.delete(ally)
- elsif !ally.disposed?
- ally.update if $game_map.in_range?(ally.character)
- end
- end
- for monster in @monsters_sprites.compact
- if monster.character.destroy and !monster.character.respawn and !monster.disposed?
- monster.dispose
- $game_monsters.delete(monster.character)
- @monsters_sprites.delete(monster)
- elsif !monster.disposed?
- monster.update if $game_map.in_range?(monster.character)
- end
- end
- for range in @range_sprites.compact
- if range.character.destroy and !range.disposed?
- range.dispose
- $game_range.delete(range.character)
- @range_sprites.delete(range)
- elsif !range.disposed?
- range.update if $game_map.in_range?(range.character)
- end
- end
- for drop in @drop_sprites.compact
- if drop.character.destroy and !drop.disposed?
- drop.update
- drop.character.character_name = ""
- unless drop.animation?
- drop.dispose
- $game_drop.delete(drop.character)
- $game_bomb.delete(drop.character)
- @drop_sprites.delete(drop)
- end
- elsif !drop.disposed?
- drop.update if $game_map.in_range?(drop.character)
- end
- end
- for ally in $game_allies.compact
- next if ally.draw
- @allies_sprites.push(Sprite_Character.new(@viewport1, ally))
- @weapon_sprites.push(Sprite_Weapon.new(@viewport1, ally))
- @shield_sprites.push(Sprite_Shield.new(@viewport1 ,ally))
- ally.draw = true
- end
- for range in $game_range.compact
- next unless $game_map.in_range?(range)
- next if range.draw
- @range_sprites.push(Sprite_Character.new(@viewport1, range))
- range.draw = true
- end
- for drop in $game_drop.compact
- next unless $game_map.in_range?(drop)
- next if drop.draw
- @drop_sprites.push(Sprite_Drop.new(@viewport1, drop))
- drop.draw = true
- end
- for bomb in $game_bomb.compact
- next unless $game_map.in_range?(bomb)
- next if bomb.draw
- @drop_sprites.push(Sprite_Drop.new(@viewport1, bomb))
- bomb.draw = true
- end
- for weapon in @weapon_sprites.compact
- next unless $game_map.in_range?(weapon.character)
- weapon.update
- end
- for shield in @shield_sprites.compact
- next unless $game_map.in_range?(shield.character)
- shield.update
- end
- end
- def dispose_characters
- requiem_abs_sp_map_dispose_characters
- @allies_sprites.compact.each { |i| i.dispose }
- @monsters_sprites.compact.each { |i| i.dispose }
- @range_sprites.compact.each { |i| i.dispose }
- @drop_sprites.compact.each { |i| i.dispose }
- @weapon_sprites.compact.each { |i| i.dispose }
- @shield_sprites.compact.each { |i| i.dispose }
- end
- def refresh_characters
- dispose_characters
- create_characters
- end
- end
- #------------------------------------------------------------------------------
- # Window Base
- #------------------------------------------------------------------------------
- class Window_Base < Window
- def draw_actor_head(actor, x, y, enabled=true)
- char_name = actor.character_name
- char_index = actor.character_index
- bitmap = Cache.character(char_name)
- sign = char_name[/^[\!\$]./]
- if sign != nil and sign.include?('$')
- cw = bitmap.width / 3
- ch = bitmap.height / 4
- else
- cw = bitmap.width / 12
- ch = bitmap.height / 8
- end
- enbl = (enabled ? 255 : 128)
- src_rect = Rect.new((char_index%4*3+1)*cw, (char_index/4*4)*ch, cw, ch/3*2)
- self.contents.blt(x, y, bitmap, src_rect, enbl)
- end
- end
- #------------------------------------------------------------------------------
- # Scene Title
- #------------------------------------------------------------------------------
- class Scene_Title < Scene_Base
- alias requiem_abs_scenetitle_create_game_objects create_game_objects
- alias requiem_abs_scenetitle_command_new_game command_new_game
- def create_game_objects
- $game_monsters = []
- $game_allies = []
- $game_range = []
- $game_drop = []
- $game_bomb = []
- requiem_abs_scenetitle_create_game_objects
- $Requiem_ABS = Requiem_ABS.new
- end
- def command_new_game
- requiem_abs_scenetitle_command_new_game
- for ally in $game_allies.compact
- ally.map_id = $data_system.start_map_id
- ally.moveto($data_system.start_x, $data_system.start_y)
- ally.move_random
- end
- end
- end
- #------------------------------------------------------------------------------
- # Scene Map
- #------------------------------------------------------------------------------
- class Scene_Map < Scene_Base
- alias requiem_abs_scenemap_update update
- def update
- requiem_abs_scenemap_update
- for ally in $game_allies.compact
- ally.update if $game_map.in_range?(ally)
- end
- for monster in $game_monsters.compact
- monster.update if $game_map.in_range?(monster)
- end
- for range in $game_range.compact
- range.update if $game_map.in_range?(range)
- end
- for drop in $game_drop.compact
- drop.update if $game_map.in_range?(drop)
- end
- for bomb in $game_bomb.compact
- bomb.update if $game_map.in_range?(bomb)
- end
- end
- def update_encounter
- end
- def refresh_sprites
- @spriteset.refresh_characters
- Cache.clear
- end
- end
- #------------------------------------------------------------------------------
- # Scene Item
- #------------------------------------------------------------------------------
- class Window_Item < Window_Selectable
- def update_help
- if $scene.is_a?(Scene_Item) and $scene.message != ""
- @help_window.set_text($scene.message)
- else
- @help_window.set_text(item == nil ? "" : item.description)
- end
- end
- end
- #------------------------------------------------------------------------------
- class Scene_Item < Scene_Base
- attr_accessor :message
- attr_accessor :delay
- alias requiem_abs_sitem_start start
- alias requiem_abs_sitem_update update
- alias requiem_abs_sitem_update_item_selection update_item_selection
- def start
- requiem_abs_sitem_start
- @actor = $game_party.members[0]
- @message = ""
- @delay = 0
- end
- def update
- requiem_abs_sitem_update
- if @delay <= 0
- @message = ""
- else
- @delay -= 1
- end
- end
- def update_item_selection
- requiem_abs_sitem_update_item_selection
- for button in @actor.item_hotkeys.keys
- next unless @item_window.item.is_a?(RPG::Item)
- next unless Input.trigger?(button)
- Sound.play_decision
- @actor.item_hotkeys[button] = @item_window.item.id
- @message = $Requiem_ABS.memorized_text
- @delay = 120
- end
- end
- end
- #------------------------------------------------------------------------------
- # Scene Skill
- #------------------------------------------------------------------------------
- class Window_Skill < Window_Selectable
- def update_help
- if $scene.is_a?(Scene_Skill) and $scene.message != ""
- @help_window.set_text($scene.message)
- else
- @help_window.set_text(skill == nil ? "" : skill.description)
- end
- end
- end
- #------------------------------------------------------------------------------
- class Scene_Skill < Scene_Base
- attr_accessor :message
- attr_accessor :delay
- alias requiem_abs_sskill_start start
- alias requiem_abs_sskill_update update
- alias requiem_abs_sskill_update_skill_selection update_skill_selection
- def start
- requiem_abs_sskill_start
- @message = ""
- @delay = 0
- end
- def update
- requiem_abs_sskill_update
- if @delay <= 0
- @message = ""
- else
- @delay -= 1
- end
- end
- def update_skill_selection
- requiem_abs_sskill_update_skill_selection
- for button in @actor.skill_hotkeys.keys
- next unless Input.trigger?(button)
- Sound.play_decision
- @actor.skill_hotkeys[button] = @skill_window.skill.id
- @message = $Requiem_ABS.memorized_text
- @delay = 120
- end
- end
- end
- #------------------------------------------------------------------------------
- # Scene File
- #------------------------------------------------------------------------------
- class Scene_File < Scene_Base
- alias requiem_abs_sfile_do_load do_load
- alias requiem_abs_sfile_write_save_data write_save_data
- alias requiem_abs_sfile_read_save_data read_save_data
- def do_load
- requiem_abs_sfile_do_load
- $game_player.refresh
- for ally in $game_allies.compact
- ally.refresh
- end
- end
- def write_save_data(file)
- requiem_abs_sfile_write_save_data(file)
- Marshal.dump($game_allies, file)
- Marshal.dump($game_monsters, file)
- Marshal.dump($game_range, file)
- Marshal.dump($game_drop, file)
- Marshal.dump($game_bomb, file)
- end
- def read_save_data(file)
- requiem_abs_sfile_read_save_data(file)
- $game_allies = Marshal.load(file)
- $game_monsters = Marshal.load(file)
- $game_range = Marshal.load(file)
- $game_drop = Marshal.load(file)
- $game_bomb = Marshal.load(file)
- end
- end
- #------------------------------------------------------------------------------
- # High Priority
- #------------------------------------------------------------------------------
- Win32API.new("kernel32", "SetPriorityClass", "pi", "i").call(-1, 0x80)
- #------------------------------------------------------------------------------
- # End of ABS
- #------------------------------------------------------------------------------
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement