rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/Game_ActionResult.rb

@@ -0,0 +1,159 @@
+#==============================================================================
+# ** Game_ActionResult
+#------------------------------------------------------------------------------
+#  This class handles the results of battle actions. It is used internally for
+# the Game_Battler class. 
+#==============================================================================
+
+class Game_ActionResult
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_accessor :used                     # used flag
+  attr_accessor :missed                   # missed flag
+  attr_accessor :evaded                   # evaded flag
+  attr_accessor :critical                 # critical flag
+  attr_accessor :success                  # success flag
+  attr_accessor :hp_damage                # HP damage
+  attr_accessor :mp_damage                # MP damage
+  attr_accessor :tp_damage                # TP damage
+  attr_accessor :hp_drain                 # HP drain
+  attr_accessor :mp_drain                 # MP drain
+  attr_accessor :added_states             # added states
+  attr_accessor :removed_states           # removed states
+  attr_accessor :added_buffs              # added buffs
+  attr_accessor :added_debuffs            # added debuffs
+  attr_accessor :removed_buffs            # removed buffs/debuffs
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize(battler)
+    @battler = battler
+    clear
+  end
+  #--------------------------------------------------------------------------
+  # * Clear
+  #--------------------------------------------------------------------------
+  def clear
+    clear_hit_flags
+    clear_damage_values
+    clear_status_effects
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Hit Flags
+  #--------------------------------------------------------------------------
+  def clear_hit_flags
+    @used = false
+    @missed = false
+    @evaded = false
+    @critical = false
+    @success = false
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Damage Values
+  #--------------------------------------------------------------------------
+  def clear_damage_values
+    @hp_damage = 0
+    @mp_damage = 0
+    @tp_damage = 0
+    @hp_drain = 0
+    @mp_drain = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Create Damage
+  #--------------------------------------------------------------------------
+  def make_damage(value, item)
+    @critical = false if value == 0
+    @hp_damage = value if item.damage.to_hp?
+    @mp_damage = value if item.damage.to_mp?
+    @mp_damage = [@battler.mp, @mp_damage].min
+    @hp_drain = @hp_damage if item.damage.drain?
+    @mp_drain = @mp_damage if item.damage.drain?
+    @hp_drain = [@battler.hp, @hp_drain].min
+    @success = true if item.damage.to_hp? || @mp_damage != 0
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Status Effects
+  #--------------------------------------------------------------------------
+  def clear_status_effects
+    @added_states = []
+    @removed_states = []
+    @added_buffs = []
+    @added_debuffs = []
+    @removed_buffs = []
+  end
+  #--------------------------------------------------------------------------
+  # * Get Added States as an Object Array
+  #--------------------------------------------------------------------------
+  def added_state_objects
+    @added_states.collect {|id| $data_states[id] }
+  end
+  #--------------------------------------------------------------------------
+  # * Get Removed States as an Object Array
+  #--------------------------------------------------------------------------
+  def removed_state_objects
+    @removed_states.collect {|id| $data_states[id] }
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Whether Some Sort of Status (Parameter or State) Was Affected
+  #--------------------------------------------------------------------------
+  def status_affected?
+    !(@added_states.empty? && @removed_states.empty? &&
+      @added_buffs.empty? && @added_debuffs.empty? && @removed_buffs.empty?)
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Final Hit 
+  #--------------------------------------------------------------------------
+  def hit?
+    @used && !@missed && !@evaded
+  end
+  #--------------------------------------------------------------------------
+  # * Get Text for HP Damage
+  #--------------------------------------------------------------------------
+  def hp_damage_text
+    if @hp_drain > 0
+      fmt = @battler.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
+      sprintf(fmt, @battler.name, Vocab::hp, @hp_drain)
+    elsif @hp_damage > 0
+      fmt = @battler.actor? ? Vocab::ActorDamage : Vocab::EnemyDamage
+      sprintf(fmt, @battler.name, @hp_damage)
+    elsif @hp_damage < 0
+      fmt = @battler.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
+      sprintf(fmt, @battler.name, Vocab::hp, -hp_damage)
+    else
+      fmt = @battler.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage
+      sprintf(fmt, @battler.name)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Get Text for MP Damage
+  #--------------------------------------------------------------------------
+  def mp_damage_text
+    if @mp_drain > 0
+      fmt = @battler.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
+      sprintf(fmt, @battler.name, Vocab::mp, @mp_drain)
+    elsif @mp_damage > 0
+      fmt = @battler.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
+      sprintf(fmt, @battler.name, Vocab::mp, @mp_damage)
+    elsif @mp_damage < 0
+      fmt = @battler.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
+      sprintf(fmt, @battler.name, Vocab::mp, -@mp_damage)
+    else
+      ""
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Get Text for TP Damage
+  #--------------------------------------------------------------------------
+  def tp_damage_text
+    if @tp_damage > 0
+      fmt = @battler.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
+      sprintf(fmt, @battler.name, Vocab::tp, @tp_damage)
+    elsif @tp_damage < 0
+      fmt = @battler.actor? ? Vocab::ActorGain : Vocab::EnemyGain
+      sprintf(fmt, @battler.name, Vocab::tp, -@tp_damage)
+    else
+      ""
+    end
+  end
+end

data/lib/rgss3_default_scripts/Game_Actor.rb

@@ -0,0 +1,696 @@
+#==============================================================================
+# ** 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