# -*- coding: utf-8 -*- #============================================================================== # ** Game_Actor #------------------------------------------------------------------------------ # This class handles actors. It is used within the Game_Actors class # ($game_actors) and is also referenced from the Game_Party class ($game_party). #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :name # Name attr_accessor :nickname # Nickname attr_reader :character_name # character graphic filename attr_reader :character_index # character graphic index attr_reader :face_name # face graphic filename attr_reader :face_index # face graphic index attr_reader :class_id # class ID attr_reader :level # level attr_reader :action_input_index # action number being input attr_reader :last_skill # For cursor memorization: Skill #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize(actor_id) super() setup(actor_id) @last_skill = Game_BaseItem.new end #-------------------------------------------------------------------------- # * Setup #-------------------------------------------------------------------------- def setup(actor_id) @actor_id = actor_id @name = actor.name @nickname = actor.nickname init_graphics @class_id = actor.class_id @level = actor.initial_level @exp = {} @equips = [] init_exp init_skills init_equips(actor.equips) clear_param_plus recover_all end #-------------------------------------------------------------------------- # * Get Actor Object #-------------------------------------------------------------------------- def actor $data_actors[@actor_id] end #-------------------------------------------------------------------------- # * Initialize Graphics #-------------------------------------------------------------------------- def init_graphics @character_name = actor.character_name @character_index = actor.character_index @face_name = actor.face_name @face_index = actor.face_index end #-------------------------------------------------------------------------- # * Get Total EXP Required for Rising to Specified Level #-------------------------------------------------------------------------- def exp_for_level(level) self.class.exp_for_level(level) end #-------------------------------------------------------------------------- # * Initialize EXP #-------------------------------------------------------------------------- def init_exp @exp[@class_id] = current_level_exp end #-------------------------------------------------------------------------- # * Get Experience #-------------------------------------------------------------------------- def exp @exp[@class_id] end #-------------------------------------------------------------------------- # * Get Minimum EXP for Current Level #-------------------------------------------------------------------------- def current_level_exp exp_for_level(@level) end #-------------------------------------------------------------------------- # * Get EXP for Next Level #-------------------------------------------------------------------------- def next_level_exp exp_for_level(@level + 1) end #-------------------------------------------------------------------------- # * Maximum Level #-------------------------------------------------------------------------- def max_level actor.max_level end #-------------------------------------------------------------------------- # * Determine Maximum Level #-------------------------------------------------------------------------- def max_level? @level >= max_level end #-------------------------------------------------------------------------- # * Initialize Skills #-------------------------------------------------------------------------- def init_skills @skills = [] self.class.learnings.each do |learning| learn_skill(learning.skill_id) if learning.level <= @level end end #-------------------------------------------------------------------------- # * Initialize Equipment # equips: An array of initial equipment #-------------------------------------------------------------------------- def init_equips(equips) @equips = Array.new(equip_slots.size) { Game_BaseItem.new } equips.each_with_index do |item_id, i| etype_id = index_to_etype_id(i) slot_id = empty_slot(etype_id) @equips[slot_id].set_equip(etype_id == 0, item_id) if slot_id end refresh end #-------------------------------------------------------------------------- # * Convert Index Set by Editor to Equipment Type ID #-------------------------------------------------------------------------- def index_to_etype_id(index) index == 1 && dual_wield? ? 0 : index end #-------------------------------------------------------------------------- # * Convert from Equipment Type to List of Slot IDs #-------------------------------------------------------------------------- def slot_list(etype_id) result = [] equip_slots.each_with_index {|e, i| result.push(i) if e == etype_id } result end #-------------------------------------------------------------------------- # * Convert from Equipment Type to Slot ID (Empty Take Precedence) #-------------------------------------------------------------------------- def empty_slot(etype_id) list = slot_list(etype_id) list.find {|i| @equips[i].is_nil? } || list[0] end #-------------------------------------------------------------------------- # * Get Equipment Slot Array #-------------------------------------------------------------------------- def equip_slots return [0,0,2,3,4] if dual_wield? # Dual wield return [0,1,2,3,4] # Normal end #-------------------------------------------------------------------------- # * Get Weapon Object Array #-------------------------------------------------------------------------- def weapons @equips.select {|item| item.is_weapon? }.collect {|item| item.object } end #-------------------------------------------------------------------------- # * Get Armor Object Array #-------------------------------------------------------------------------- def armors @equips.select {|item| item.is_armor? }.collect {|item| item.object } end #-------------------------------------------------------------------------- # * Get Equipped Item Object Array #-------------------------------------------------------------------------- def equips @equips.collect {|item| item.object } end #-------------------------------------------------------------------------- # * Determine if Equipment Change Possible # slot_id: Equipment slot ID #-------------------------------------------------------------------------- def equip_change_ok?(slot_id) return false if equip_type_fixed?(equip_slots[slot_id]) return false if equip_type_sealed?(equip_slots[slot_id]) return true end #-------------------------------------------------------------------------- # * Change Equipment # slot_id: Equipment slot ID # item: Weapon/armor (remove equipment if nil) #-------------------------------------------------------------------------- def change_equip(slot_id, item) return unless trade_item_with_party(item, equips[slot_id]) return if item && equip_slots[slot_id] != item.etype_id @equips[slot_id].object = item refresh end #-------------------------------------------------------------------------- # * Forcibly Change Equipment # slot_id: Equipment slot ID # item: Weapon/armor (remove equipment if nil) #-------------------------------------------------------------------------- def force_change_equip(slot_id, item) @equips[slot_id].object = item release_unequippable_items(false) refresh end #-------------------------------------------------------------------------- # * Trade Item with Party # new_item: Item to get from party # old_item: Item to give to party #-------------------------------------------------------------------------- def trade_item_with_party(new_item, old_item) return false if new_item && !$game_party.has_item?(new_item) $game_party.gain_item(old_item, 1) $game_party.lose_item(new_item, 1) return true end #-------------------------------------------------------------------------- # * Change Equipment (Specify with ID) # slot_id: Equipment slot ID # item_id: Weapons/armor ID #-------------------------------------------------------------------------- def change_equip_by_id(slot_id, item_id) if equip_slots[slot_id] == 0 change_equip(slot_id, $data_weapons[item_id]) else change_equip(slot_id, $data_armors[item_id]) end end #-------------------------------------------------------------------------- # * Discard Equipment # item: Weapon/armor to discard #-------------------------------------------------------------------------- def discard_equip(item) slot_id = equips.index(item) @equips[slot_id].object = nil if slot_id end #-------------------------------------------------------------------------- # * Remove Equipment that Cannot Be Equipped # item_gain: Return removed equipment to party. #-------------------------------------------------------------------------- def release_unequippable_items(item_gain = true) loop do last_equips = equips.dup @equips.each_with_index do |item, i| if !equippable?(item.object) || item.object.etype_id != equip_slots[i] trade_item_with_party(nil, item.object) if item_gain item.object = nil end end return if equips == last_equips end end #-------------------------------------------------------------------------- # * Remove All Equipment #-------------------------------------------------------------------------- def clear_equipments equip_slots.size.times do |i| change_equip(i, nil) if equip_change_ok?(i) end end #-------------------------------------------------------------------------- # * Ultimate Equipment #-------------------------------------------------------------------------- def optimize_equipments clear_equipments equip_slots.size.times do |i| next if !equip_change_ok?(i) items = $game_party.equip_items.select do |item| item.etype_id == equip_slots[i] && equippable?(item) && item.performance >= 0 end change_equip(i, items.max_by {|item| item.performance }) end end #-------------------------------------------------------------------------- # * Determine if Skill-Required Weapon Is Equipped #-------------------------------------------------------------------------- def skill_wtype_ok?(skill) wtype_id1 = skill.required_wtype_id1 wtype_id2 = skill.required_wtype_id2 return true if wtype_id1 == 0 && wtype_id2 == 0 return true if wtype_id1 > 0 && wtype_equipped?(wtype_id1) return true if wtype_id2 > 0 && wtype_equipped?(wtype_id2) return false end #-------------------------------------------------------------------------- # * Determine if Specific Type of Weapon Is Equipped #-------------------------------------------------------------------------- def wtype_equipped?(wtype_id) weapons.any? {|weapon| weapon.wtype_id == wtype_id } end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh release_unequippable_items super end #-------------------------------------------------------------------------- # * Determine if Actor or Not #-------------------------------------------------------------------------- def actor? return true end #-------------------------------------------------------------------------- # * Get Allied Units #-------------------------------------------------------------------------- def friends_unit $game_party end #-------------------------------------------------------------------------- # * Get Enemy Units #-------------------------------------------------------------------------- def opponents_unit $game_troop end #-------------------------------------------------------------------------- # * Get Actor ID #-------------------------------------------------------------------------- def id @actor_id end #-------------------------------------------------------------------------- # * Get Index #-------------------------------------------------------------------------- def index $game_party.members.index(self) end #-------------------------------------------------------------------------- # * Determine Battle Members #-------------------------------------------------------------------------- def battle_member? $game_party.battle_members.include?(self) end #-------------------------------------------------------------------------- # * Get Class Object #-------------------------------------------------------------------------- def class $data_classes[@class_id] end #-------------------------------------------------------------------------- # * Get Skill Object Array #-------------------------------------------------------------------------- def skills (@skills | added_skills).sort.collect {|id| $data_skills[id] } end #-------------------------------------------------------------------------- # * Get Array of Currently Usable Skills #-------------------------------------------------------------------------- def usable_skills skills.select {|skill| usable?(skill) } end #-------------------------------------------------------------------------- # * Get Array of All Objects Retaining Features #-------------------------------------------------------------------------- def feature_objects super + [actor] + [self.class] + equips.compact end #-------------------------------------------------------------------------- # * Get Attack Element #-------------------------------------------------------------------------- def atk_elements set = super set |= [1] if weapons.compact.empty? # Unarmed: Physical element return set end #-------------------------------------------------------------------------- # * Get Maximum Value of Parameter #-------------------------------------------------------------------------- def param_max(param_id) return 9999 if param_id == 0 # MHP return super end #-------------------------------------------------------------------------- # * Get Base Value of Parameter #-------------------------------------------------------------------------- def param_base(param_id) self.class.params[param_id, @level] end #-------------------------------------------------------------------------- # * Get Added Value of Parameter #-------------------------------------------------------------------------- def param_plus(param_id) equips.compact.inject(super) {|r, item| r += item.params[param_id] } end #-------------------------------------------------------------------------- # * Get Normal Attack Animation ID #-------------------------------------------------------------------------- def atk_animation_id1 if dual_wield? return weapons[0].animation_id if weapons[0] return weapons[1] ? 0 : 1 else return weapons[0] ? weapons[0].animation_id : 1 end end #-------------------------------------------------------------------------- # * Get Animation ID of Normal Attack (Dual Wield: Weapon 2) #-------------------------------------------------------------------------- def atk_animation_id2 if dual_wield? return weapons[1] ? weapons[1].animation_id : 0 else return 0 end end #-------------------------------------------------------------------------- # * Change Experience # show : Level up display flag #-------------------------------------------------------------------------- def change_exp(exp, show) @exp[@class_id] = [exp, 0].max last_level = @level last_skills = skills level_up while !max_level? && self.exp >= next_level_exp level_down while self.exp < current_level_exp display_level_up(skills - last_skills) if show && @level > last_level refresh end #-------------------------------------------------------------------------- # * Get Experience #-------------------------------------------------------------------------- def exp @exp[@class_id] end #-------------------------------------------------------------------------- # * Level Up #-------------------------------------------------------------------------- def level_up @level += 1 self.class.learnings.each do |learning| learn_skill(learning.skill_id) if learning.level == @level end end #-------------------------------------------------------------------------- # * Level Down #-------------------------------------------------------------------------- def level_down @level -= 1 end #-------------------------------------------------------------------------- # * Show Level Up Message # new_skills : Array of newly learned skills #-------------------------------------------------------------------------- def display_level_up(new_skills) $game_message.new_page $game_message.add(sprintf(Vocab::LevelUp, @name, Vocab::level, @level)) new_skills.each do |skill| $game_message.add(sprintf(Vocab::ObtainSkill, skill.name)) end end #-------------------------------------------------------------------------- # * Get EXP (Account for Experience Rate) #-------------------------------------------------------------------------- def gain_exp(exp) change_exp(self.exp + (exp * final_exp_rate).to_i, true) end #-------------------------------------------------------------------------- # * Calculate Final EXP Rate #-------------------------------------------------------------------------- def final_exp_rate exr * (battle_member? ? 1 : reserve_members_exp_rate) end #-------------------------------------------------------------------------- # * Get EXP Rate for Reserve Members #-------------------------------------------------------------------------- def reserve_members_exp_rate $data_system.opt_extra_exp ? 1 : 0 end #-------------------------------------------------------------------------- # * Change Level # show : Level up display flag #-------------------------------------------------------------------------- def change_level(level, show) level = [[level, max_level].min, 1].max change_exp(exp_for_level(level), show) end #-------------------------------------------------------------------------- # * Learn Skill #-------------------------------------------------------------------------- def learn_skill(skill_id) unless skill_learn?($data_skills[skill_id]) @skills.push(skill_id) @skills.sort! end end #-------------------------------------------------------------------------- # * Forget Skill #-------------------------------------------------------------------------- def forget_skill(skill_id) @skills.delete(skill_id) end #-------------------------------------------------------------------------- # * Determine if Skill Is Already Learned #-------------------------------------------------------------------------- def skill_learn?(skill) skill.is_a?(RPG::Skill) && @skills.include?(skill.id) end #-------------------------------------------------------------------------- # * Get Description #-------------------------------------------------------------------------- def description actor.description end #-------------------------------------------------------------------------- # * Change Class # keep_exp: Keep EXP #-------------------------------------------------------------------------- def change_class(class_id, keep_exp = false) @exp[class_id] = exp if keep_exp @class_id = class_id change_exp(@exp[@class_id] || 0, false) refresh end #-------------------------------------------------------------------------- # * Change Graphics #-------------------------------------------------------------------------- def set_graphic(character_name, character_index, face_name, face_index) @character_name = character_name @character_index = character_index @face_name = face_name @face_index = face_index end #-------------------------------------------------------------------------- # * Use Sprites? #-------------------------------------------------------------------------- def use_sprite? return false end #-------------------------------------------------------------------------- # * Execute Damage Effect #-------------------------------------------------------------------------- def perform_damage_effect $game_troop.screen.start_shake(5, 5, 10) @sprite_effect_type = :blink Sound.play_actor_damage end #-------------------------------------------------------------------------- # * Execute Collapse Effect #-------------------------------------------------------------------------- def perform_collapse_effect if $game_party.in_battle @sprite_effect_type = :collapse Sound.play_actor_collapse end end #-------------------------------------------------------------------------- # * Create Action Candidate List for Auto Battle #-------------------------------------------------------------------------- def make_action_list list = [] list.push(Game_Action.new(self).set_attack.evaluate) usable_skills.each do |skill| list.push(Game_Action.new(self).set_skill(skill.id).evaluate) end list end #-------------------------------------------------------------------------- # * Create Action During Auto Battle #-------------------------------------------------------------------------- def make_auto_battle_actions @actions.size.times do |i| @actions[i] = make_action_list.max_by {|action| action.value } end end #-------------------------------------------------------------------------- # * Create Action During Confusion #-------------------------------------------------------------------------- def make_confusion_actions @actions.size.times do |i| @actions[i].set_confusion end end #-------------------------------------------------------------------------- # * Create Battle Action #-------------------------------------------------------------------------- def make_actions super if auto_battle? make_auto_battle_actions elsif confusion? make_confusion_actions end end #-------------------------------------------------------------------------- # * Processing Performed When Player Takes 1 Step #-------------------------------------------------------------------------- def on_player_walk @result.clear check_floor_effect if $game_player.normal_walk? turn_end_on_map states.each {|state| update_state_steps(state) } show_added_states show_removed_states end end #-------------------------------------------------------------------------- # * Update Step Count for State #-------------------------------------------------------------------------- def update_state_steps(state) if state.remove_by_walking @state_steps[state.id] -= 1 if @state_steps[state.id] > 0 remove_state(state.id) if @state_steps[state.id] == 0 end end #-------------------------------------------------------------------------- # * Show Added State #-------------------------------------------------------------------------- def show_added_states @result.added_state_objects.each do |state| $game_message.add(name + state.message1) unless state.message1.empty? end end #-------------------------------------------------------------------------- # * Show Removed State #-------------------------------------------------------------------------- def show_removed_states @result.removed_state_objects.each do |state| $game_message.add(name + state.message4) unless state.message4.empty? end end #-------------------------------------------------------------------------- # * Number of Steps Regarded as One Turn in Battle #-------------------------------------------------------------------------- def steps_for_turn return 20 end #-------------------------------------------------------------------------- # * End of Turn Processing on Map Screen #-------------------------------------------------------------------------- def turn_end_on_map if $game_party.steps % steps_for_turn == 0 on_turn_end perform_map_damage_effect if @result.hp_damage > 0 end end #-------------------------------------------------------------------------- # * Determine Floor Effect #-------------------------------------------------------------------------- def check_floor_effect execute_floor_damage if $game_player.on_damage_floor? end #-------------------------------------------------------------------------- # * Floor Damage Processing #-------------------------------------------------------------------------- def execute_floor_damage damage = (basic_floor_damage * fdr).to_i self.hp -= [damage, max_floor_damage].min perform_map_damage_effect if damage > 0 end #-------------------------------------------------------------------------- # * Get Base Value for Floor Damage #-------------------------------------------------------------------------- def basic_floor_damage return 10 end #-------------------------------------------------------------------------- # * Get Maximum Value for Floor Damage #-------------------------------------------------------------------------- def max_floor_damage $data_system.opt_floor_death ? hp : [hp - 1, 0].max end #-------------------------------------------------------------------------- # * Execute Damage Effect on Map #-------------------------------------------------------------------------- def perform_map_damage_effect $game_map.screen.start_flash_for_damage end #-------------------------------------------------------------------------- # * Clear Actions #-------------------------------------------------------------------------- def clear_actions super @action_input_index = 0 end #-------------------------------------------------------------------------- # * Get Action Being Input #-------------------------------------------------------------------------- def input @actions[@action_input_index] end #-------------------------------------------------------------------------- # * To Next Command Input #-------------------------------------------------------------------------- def next_command return false if @action_input_index >= @actions.size - 1 @action_input_index += 1 return true end #-------------------------------------------------------------------------- # * To Previous Command Input #-------------------------------------------------------------------------- def prior_command return false if @action_input_index <= 0 @action_input_index -= 1 return true end end