#============================================================================== # ** Game_Battler #------------------------------------------------------------------------------ # A battler class with methods for sprites and actions added. This class # is used as a super class of the Game_Actor class and Game_Enemy class. #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # * Constants (Effects) #-------------------------------------------------------------------------- EFFECT_RECOVER_HP = 11 # HP Recovery EFFECT_RECOVER_MP = 12 # MP Recovery EFFECT_GAIN_TP = 13 # TP Gain EFFECT_ADD_STATE = 21 # Add State EFFECT_REMOVE_STATE = 22 # Remove State #EFFECT_ADD_BUFF = 31 # Add Buff #EFFECT_ADD_DEBUFF = 32 # Add Debuff #EFFECT_REMOVE_BUFF = 33 # Remove Buff #EFFECT_REMOVE_DEBUFF = 34 # Remove Debuff EFFECT_SPECIAL = 41 # Special Effect EFFECT_GROW = 42 # Raise Parameter EFFECT_LEARN_SKILL = 43 # Learn Skill EFFECT_COMMON_EVENT = 44 # Common Events #-------------------------------------------------------------------------- # * Constants (Special Effects) #-------------------------------------------------------------------------- SPECIAL_EFFECT_ESCAPE = 0 # Escape #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :battler_name # battle graphic filename attr_reader :battler_hue # battle graphic hue attr_reader :action_times # action times attr_reader :actions # combat actions (action side) attr_reader :speed # action speed attr_reader :result # action result (target side) attr_accessor :last_target_index # last target attr_accessor :animation_id # animation ID attr_accessor :animation_mirror # animation flip horizontal flag attr_accessor :sprite_effect_type # sprite effect attr_accessor :magic_reflection # reflection flag #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize @battler_name = "" @battler_hue = 0 @actions = [] @speed = 0 @result = Game_ActionResult.new(self) @last_target_index = 0 @guarding = false clear_sprite_effects super end #-------------------------------------------------------------------------- # * Clear Sprite Effects #-------------------------------------------------------------------------- def clear_sprite_effects @animation_id = 0 @animation_mirror = false @sprite_effect_type = nil end #-------------------------------------------------------------------------- # * Clear Actions #-------------------------------------------------------------------------- def clear_actions @actions.clear end #-------------------------------------------------------------------------- # * Processing Performed When Action Restriction Occurs #-------------------------------------------------------------------------- def on_restrict clear_actions states.each do |state| remove_state(state.id) if state.remove_by_restriction end end #-------------------------------------------------------------------------- # * Reset State Counts (Turns and Steps) #-------------------------------------------------------------------------- def reset_state_counts(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) return prp "remove_state #{state_id} not found",1 if !state_id state = $data_states[state_id] variance = 1 + [state.max_turns - state.min_turns, 0].max #@state_turns[state_id] = state.min_turns + rand(variance) @state_steps[state_id] = state.steps_to_remove @state_frames[state_id] = state.steps_to_remove * 60 end #-------------------------------------------------------------------------- # * Remove State #-------------------------------------------------------------------------- def remove_state(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) return prp "remove_state #{state_id} not found",1 if !state_id if state?(state_id) revive if state_id == death_state_id erase_state(state_id) refresh #@result.removed_states.push(state_id).uniq! end end #-------------------------------------------------------------------------- # * Knock Out #-------------------------------------------------------------------------- def die @hp = 0 clear_states clear_buffs end #-------------------------------------------------------------------------- # * Revive from Knock Out #-------------------------------------------------------------------------- def revive @hp = 1 if @hp == 0 end #-------------------------------------------------------------------------- # * Escape #-------------------------------------------------------------------------- def escape hide if $game_party.in_battle clear_actions clear_states Sound.play_escape end #-------------------------------------------------------------------------- # * Add Buff #-------------------------------------------------------------------------- #def add_buff(param_id, turns) # return unless alive? # @buffs[param_id] += 1 unless buff_max?(param_id) # erase_buff(param_id) if debuff?(param_id) # overwrite_buff_turns(param_id, turns) # @result.added_buffs.push(param_id).uniq! # refresh #end #-------------------------------------------------------------------------- # * Add Debuff #-------------------------------------------------------------------------- def add_debuff(param_id, turns) return unless alive? @buffs[param_id] -= 1 unless debuff_max?(param_id) erase_buff(param_id) if buff?(param_id) overwrite_buff_turns(param_id, turns) @result.added_debuffs.push(param_id).uniq! refresh end #-------------------------------------------------------------------------- # * Remove Buff/Debuff #-------------------------------------------------------------------------- def remove_buff(param_id) return unless alive? return if @buffs[param_id] == 0 erase_buff(param_id) @buff_turns.delete(param_id) @result.removed_buffs.push(param_id).uniq! refresh end #-------------------------------------------------------------------------- # * Erase Buff/Debuff #-------------------------------------------------------------------------- def erase_buff(param_id) @buffs[param_id] = 0 @buff_turns[param_id] = 0 end #-------------------------------------------------------------------------- # * Determine Buff Status #-------------------------------------------------------------------------- def buff?(param_id) @buffs[param_id] > 0 end #-------------------------------------------------------------------------- # * Determine Debuff Status #-------------------------------------------------------------------------- def debuff?(param_id) @buffs[param_id] < 0 end #-------------------------------------------------------------------------- # * Determine if Buff Is at Maximum Level #-------------------------------------------------------------------------- def buff_max?(param_id) @buffs[param_id] == 2 end #-------------------------------------------------------------------------- # * Determine if Debuff Is at Maximum Level #-------------------------------------------------------------------------- def debuff_max?(param_id) @buffs[param_id] == -2 end #-------------------------------------------------------------------------- # * Overwrite Buff/Debuff Turns # Doesn't overwrite if number of turns would become shorter. #-------------------------------------------------------------------------- def overwrite_buff_turns(param_id, turns) @buff_turns[param_id] = turns if @buff_turns[param_id].to_i < turns end #-------------------------------------------------------------------------- # * Update Buff/Debuff Turn Count #-------------------------------------------------------------------------- def update_buff_turns @buff_turns.keys.each do |param_id| @buff_turns[param_id] -= 1 if @buff_turns[param_id] > 0 end end #-------------------------------------------------------------------------- # * Remove Battle States #-------------------------------------------------------------------------- #def remove_battle_states # states.each do |state| # remove_state(state.id) if state.remove_at_battle_end # end #end #-------------------------------------------------------------------------- # * Remove All Buffs/Debuffs #-------------------------------------------------------------------------- def remove_all_buffs @buffs.size.times {|param_id| remove_buff(param_id) } end #-------------------------------------------------------------------------- # * Automatically Remove States # timing: Timing (1: End of action 2: End of turn) #-------------------------------------------------------------------------- def remove_states_auto(timing) states.each do |state| # if @state_turns[state.id] == 0 && state.auto_removal_timing == timing # remove_state(state.id) # end end end #-------------------------------------------------------------------------- # * Automatically Remove Buffs/Debuffs #-------------------------------------------------------------------------- def remove_buffs_auto @buffs.size.times do |param_id| next if @buffs[param_id] == 0 || @buff_turns[param_id] > 0 remove_buff(param_id) end end #-------------------------------------------------------------------------- # * Remove State by Damage #-------------------------------------------------------------------------- def remove_states_by_damage states.each do |state| if state.remove_by_damage && rand(100) < state.chance_by_damage remove_state(state.id) end end end #-------------------------------------------------------------------------- # * Determine Action Times #-------------------------------------------------------------------------- def make_action_times action_plus_set.inject(1) {|r, p| rand < p ? r + 1 : r } end #-------------------------------------------------------------------------- # * Create Battle Action #-------------------------------------------------------------------------- def make_actions clear_actions return unless movable? @actions = Array.new(make_action_times) { Game_Action.new(self) } end #-------------------------------------------------------------------------- # * Determine Action Speed #-------------------------------------------------------------------------- def make_speed @speed = @actions.collect {|action| action.speed }.min || 0 end #-------------------------------------------------------------------------- # * Get Current Action #-------------------------------------------------------------------------- def current_action @actions[0] end #-------------------------------------------------------------------------- # * Remove Current Action #-------------------------------------------------------------------------- def remove_current_action @actions.shift end #-------------------------------------------------------------------------- # * Force Action #-------------------------------------------------------------------------- def force_action(skill_id, target_index) clear_actions action = Game_Action.new(self, true) action.set_skill(skill_id) if target_index == -2 action.target_index = last_target_index elsif target_index == -1 action.decide_random_target else action.target_index = target_index end @actions.push(action) end #-------------------------------------------------------------------------- # * Calculate Damage #-------------------------------------------------------------------------- #def make_damage_value(user, item) # value = item.damage.eval(user, self, $game_variables) # value *= item_element_rate(user, item) # value *= pdr if item.physical? # value *= mdr if item.magical? # value *= rec if item.damage.recover? # value = apply_critical(value) if @result.critical # value = apply_variance(value, item.damage.variance) # value = apply_guard(value) # @result.make_damage(value.to_i, item) #end #-------------------------------------------------------------------------- # * Get Element Modifier for Skill/Item #-------------------------------------------------------------------------- def item_element_rate(user, item) if item.damage.element_id < 0 user.atk_elements.empty? ? 1.0 : elements_max_rate(user.atk_elements) else element_rate(item.damage.element_id) end end #-------------------------------------------------------------------------- # * Get Maximum Elemental Adjustment Amount # elements : An array of attribute IDs # Returns the most effective adjustment of all elemental alignments. #-------------------------------------------------------------------------- def elements_max_rate(elements) elements.inject([0.0]) {|r, i| r.push(element_rate(i)) }.max end #-------------------------------------------------------------------------- # * Apply Critical #-------------------------------------------------------------------------- def apply_critical(damage) damage * 3 end #-------------------------------------------------------------------------- # * Applying Variance #-------------------------------------------------------------------------- def apply_variance(damage, variance) amp = [damage.abs * variance / 100, 0].max.to_i var = rand(amp + 1) + rand(amp + 1) - amp damage >= 0 ? damage + var : damage - var end #-------------------------------------------------------------------------- # * Applying Guard Adjustment #-------------------------------------------------------------------------- def apply_guard(damage) damage / (damage > 0 && guard? ? 2 * grd : 1) end #-------------------------------------------------------------------------- # * Damage Processing # @result.hp_damage @result.mp_damage @result.hp_drain # @result.mp_drain must be set before call. #-------------------------------------------------------------------------- #def execute_damage(user) # on_damage(@result.hp_damage) if @result.hp_damage > 0 # self.hp -= @result.hp_damage # self.mp -= @result.mp_damage # user.hp += @result.hp_drain # user.mp += @result.mp_drain #end #-------------------------------------------------------------------------- # * Use Skill/Item # Called for the acting side and applies the effect to other than the user. #-------------------------------------------------------------------------- def use_item(item) pay_skill_cost(item) if item.is_a?(RPG::Skill) consume_item(item) if item.consumable end #-------------------------------------------------------------------------- # * Consume Items #-------------------------------------------------------------------------- def consume_item(item) $game_party.consume_item(item) end #-------------------------------------------------------------------------- # * Test Skill/Item Application # Used to determine, for example, if a character is already fully healed # and so cannot recover anymore. #-------------------------------------------------------------------------- def item_test(user, item) return false if item.for_dead_friend? != dead? return true if $game_party.in_battle return true if item.for_opponent? return true if item.damage.recover? && item.damage.to_hp? && hp < mhp return true if item.damage.recover? && item.damage.to_mp? && mp < mmp return true if item_has_any_valid_effects?(user, item) return false end #-------------------------------------------------------------------------- # * Determine if Skill/Item Has Any Valid Effects #-------------------------------------------------------------------------- def item_has_any_valid_effects?(user, item) #item.effects.any? {|effect| item_effect_test(user, item, effect) } end #-------------------------------------------------------------------------- # * Calculate Counterattack Rate for Skill/Item #-------------------------------------------------------------------------- def item_cnt(user, item) return 0 unless item.physical? # Hit type is not physical return 0 unless opposite?(user) # No counterattack on allies return cnt # Return counterattack rate end #-------------------------------------------------------------------------- # * Calculate Reflection Rate of Skill/Item #-------------------------------------------------------------------------- def item_mrf(user, item) return mrf if item.magical? # Return magic reflection if magic attack return 0 end #-------------------------------------------------------------------------- # * Calculate Hit Rate of Skill/Item #-------------------------------------------------------------------------- def item_hit(user, item) rate = item.success_rate * 0.01 # Get success rate rate *= user.hit if item.physical? # Physical attack: Multiply hit rate return rate # Return calculated hit rate end #-------------------------------------------------------------------------- # * Calculate Evasion Rate for Skill/Item #-------------------------------------------------------------------------- def item_eva(user, item) return eva if item.physical? # Return evasion if physical attack return mev if item.magical? # Return magic evasion if magic attack return 0 end #-------------------------------------------------------------------------- # * Calculate Critical Rate of Skill/Item #-------------------------------------------------------------------------- def item_cri(user, item) item.damage.critical ? user.cri * (1 - cev) : 0 end #-------------------------------------------------------------------------- # * Apply Normal Attack Effects #-------------------------------------------------------------------------- def attack_apply(attacker) item_apply(attacker, $data_skills[attacker.attack_skill_id]) end #-------------------------------------------------------------------------- # * Apply Effect of Skill/Item #-------------------------------------------------------------------------- def item_apply(user, item) @result.clear #@result.used = item_test(user, item) #@result.missed = (@result.used && rand >= item_hit(user, item)) #@result.evaded = (!@result.missed && rand < item_eva(user, item)) #if @result.hit? #unless item.damage.none? # @result.critical = (rand < item_cri(user, item)) # make_damage_value(user, item) # execute_damage(user) #end #item.effects.each {|effect| item_effect_apply(user, item, effect) } #item_user_effect(user, item) #end end #-------------------------------------------------------------------------- # * Test Effect #-------------------------------------------------------------------------- #def item_effect_test(user, item, effect) # #case effect.code # #when EFFECT_RECOVER_HP # # hp < mhp || effect.value1 < 0 || effect.value2 < 0 # #when EFFECT_RECOVER_MP # # mp < mmp || effect.value1 < 0 || effect.value2 < 0 # #when EFFECT_ADD_STATE # # !(state_stack(effect.data_id) >= $data_states[effect.data_id].max_stacks) # #when EFFECT_REMOVE_STATE # # state?(effect.data_id) # #when EFFECT_ADD_BUFF # # !buff_max?(effect.data_id) # #when EFFECT_ADD_DEBUFF # # !debuff_max?(effect.data_id) # #when EFFECT_REMOVE_BUFF # # buff?(effect.data_id) # #when EFFECT_REMOVE_DEBUFF # # debuff?(effect.data_id) # #when EFFECT_LEARN_SKILL # # actor? && !skills.include?($data_skills[effect.data_id]) # #else # # true # #end #end #-------------------------------------------------------------------------- # * Apply Effect #-------------------------------------------------------------------------- def item_effect_apply(user, item, effect) method_table = { #EFFECT_RECOVER_HP => :item_effect_recover_hp, #EFFECT_RECOVER_MP => :item_effect_recover_mp, #EFFECT_GAIN_TP => :item_effect_gain_tp, EFFECT_ADD_STATE => :item_effect_add_state, EFFECT_REMOVE_STATE => :item_effect_remove_state, #EFFECT_ADD_BUFF => :item_effect_add_buff, #EFFECT_ADD_DEBUFF => :item_effect_add_debuff, #EFFECT_REMOVE_BUFF => :item_effect_remove_buff, #EFFECT_REMOVE_DEBUFF => :item_effect_remove_debuff, EFFECT_SPECIAL => :item_effect_special, EFFECT_GROW => :item_effect_grow, EFFECT_LEARN_SKILL => :item_effect_learn_skill, EFFECT_COMMON_EVENT => :item_effect_common_event, } method_name = method_table[effect.code] send(method_name, user, item, effect) if method_name end #-------------------------------------------------------------------------- # * [HP Recovery] Effect #-------------------------------------------------------------------------- #def item_effect_recover_hp(user, item, effect) # value = (mhp * effect.value1 + effect.value2) * rec # value *= user.pha if item.is_a?(RPG::Item) # value = value.to_i # @result.hp_damage -= value # @result.success = true # self.hp += value #end ##-------------------------------------------------------------------------- ## * [MP Recovery] Effect ##-------------------------------------------------------------------------- #def item_effect_recover_mp(user, item, effect) # value = (mmp * effect.value1 + effect.value2) * rec # value *= user.pha if item.is_a?(RPG::Item) # value = value.to_i # @result.mp_damage -= value # @result.success = true if value != 0 # self.mp += value #end ##-------------------------------------------------------------------------- ## * [TP Gain] Effect ##-------------------------------------------------------------------------- #def item_effect_gain_tp(user, item, effect) # value = effect.value1.to_i # @result.tp_damage -= value # @result.success = true if value != 0 # self.tp += value #end #-------------------------------------------------------------------------- # * [Add State] Effect: Normal Attack #-------------------------------------------------------------------------- def item_effect_add_state_attack(user, item, effect) user.atk_states.each do |state_id| chance = effect.value1 chance *= state_rate(state_id) chance *= user.atk_states_rate(state_id) chance *= luk_effect_rate(user) if rand < chance add_state(state_id) @result.success = true end end end #-------------------------------------------------------------------------- # * [Add State] Effect: Normal #-------------------------------------------------------------------------- def item_effect_add_state_normal(user, item, effect) chance = effect.value1 chance *= state_rate(effect.data_id) if opposite?(user) chance *= luk_effect_rate(user) if opposite?(user) if rand < chance add_state(effect.data_id) @result.success = true end end #-------------------------------------------------------------------------- # * [Remove State] Effect (Redefined) #-------------------------------------------------------------------------- def item_effect_remove_state(user, item, effect) chance = effect.value1 if rand < chance remove_state_stack(effect.data_id) @result.success = true end end def remove_state_stack(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) return prp "remove_state_stack #{state_id} not found",1 if !state_id case @states.count(state_id) when 0 return when 1 remove_state(state_id) else @states.delete_at(@states.index(state_id)) @result.removed_states.push(state_id).uniq! refresh end @stat_changed=true #verb req update LonaCHS and portrait end #-------------------------------------------------------------------------- # * [Buff] Effect #-------------------------------------------------------------------------- #def item_effect_add_buff(user, item, effect) # add_buff(effect.data_id, effect.value1) # @result.success = true #end #-------------------------------------------------------------------------- # * [Debuff] Effect #-------------------------------------------------------------------------- #def item_effect_add_debuff(user, item, effect) # chance = debuff_rate(effect.data_id) * luk_effect_rate(user) # if rand < chance # add_debuff(effect.data_id, effect.value1) # @result.success = true # end #end #-------------------------------------------------------------------------- # * [Remove Buff] Effect #-------------------------------------------------------------------------- #def item_effect_remove_buff(user, item, effect) # remove_buff(effect.data_id) if @buffs[effect.data_id] > 0 # @result.success = true #end #-------------------------------------------------------------------------- # * [Remove Debuff] Effect #-------------------------------------------------------------------------- #def item_effect_remove_debuff(user, item, effect) # remove_buff(effect.data_id) if @buffs[effect.data_id] < 0 # @result.success = true #end #-------------------------------------------------------------------------- # * [Special Effect] Effect #-------------------------------------------------------------------------- def item_effect_special(user, item, effect) case effect.data_id when SPECIAL_EFFECT_ESCAPE escape end @result.success = true end #-------------------------------------------------------------------------- # * [Raise Parameter] Effect #-------------------------------------------------------------------------- def item_effect_grow(user, item, effect) add_param(effect.data_id, effect.value1.to_i) @result.success = true end #-------------------------------------------------------------------------- # * [Learn Skill] Effect #-------------------------------------------------------------------------- def item_effect_learn_skill(user, item, effect) learn_skill(effect.data_id) if actor? @result.success = true end #-------------------------------------------------------------------------- # * [Common Event] Effect #-------------------------------------------------------------------------- def item_effect_common_event(user, item, effect) end #-------------------------------------------------------------------------- # * Effect of Skill/Item on Using Side #-------------------------------------------------------------------------- #def item_user_effect(user, item) # user.tp += item.tp_gain * user.tcr #end #-------------------------------------------------------------------------- # * Get Effect Change Rate by Luck #-------------------------------------------------------------------------- def luk_effect_rate(user) [1.0 + (user.luk - luk) * 0.001, 0.0].max end #-------------------------------------------------------------------------- # * Determine if Hostile Relation #-------------------------------------------------------------------------- def opposite?(battler) actor? != battler.actor? || battler.magic_reflection end #-------------------------------------------------------------------------- # * Effect When Taking Damage on Map #-------------------------------------------------------------------------- def perform_map_damage_effect end #-------------------------------------------------------------------------- # * Initialize TP #-------------------------------------------------------------------------- def init_tp self.tp = rand * 25 end #-------------------------------------------------------------------------- # * Clear TP #-------------------------------------------------------------------------- def clear_tp self.tp = 0 end #-------------------------------------------------------------------------- # * Charge TP by Damage Suffered #-------------------------------------------------------------------------- def charge_tp_by_damage(damage_rate) self.tp += 50 * damage_rate * tcr end #-------------------------------------------------------------------------- # * Regenerate HP #-------------------------------------------------------------------------- #def regenerate_hp # damage = -(mhp * hrg).to_i # perform_map_damage_effect if $game_party.in_battle && damage > 0 # @result.hp_damage = [damage, max_slip_damage].min # self.hp -= @result.hp_damage #end #-------------------------------------------------------------------------- # * Get Maximum Value of Slip Damage #-------------------------------------------------------------------------- def max_slip_damage $data_system.opt_slip_death ? hp : [hp - 1, 0].max end #-------------------------------------------------------------------------- # * Regenerate MP #-------------------------------------------------------------------------- #def regenerate_mp # @result.mp_damage = -(mmp * mrg).to_i # self.mp -= @result.mp_damage #end #-------------------------------------------------------------------------- # * Regenerate TP #-------------------------------------------------------------------------- #def regenerate_tp # self.tp += 100 * trg #end #-------------------------------------------------------------------------- # * Regenerate All #-------------------------------------------------------------------------- #def regenerate_all # if alive? # regenerate_hp # regenerate_mp # regenerate_tp # end #end #-------------------------------------------------------------------------- # * Processing at Start of Battle #-------------------------------------------------------------------------- def on_battle_start init_tp unless preserve_tp? end #-------------------------------------------------------------------------- # * Processing at End of Action #-------------------------------------------------------------------------- def on_action_end @result.clear remove_states_auto(1) remove_buffs_auto end #-------------------------------------------------------------------------- # * Processing at End of Turn #-------------------------------------------------------------------------- #def on_turn_end # @result.clear # #regenerate_all # #update_state_turns # update_buff_turns # remove_states_auto(2) #end #-------------------------------------------------------------------------- # * Processing at End of Battle #-------------------------------------------------------------------------- def on_battle_end @result.clear remove_all_buffs clear_actions clear_tp unless preserve_tp? appear end #-------------------------------------------------------------------------- # * Processing When Suffering Damage #-------------------------------------------------------------------------- def on_damage(value) remove_states_by_damage charge_tp_by_damage(value.to_f / mhp) end #-------------------------------------------------------------------------- # * Clear State Information #-------------------------------------------------------------------------- def clear_states super @result.clear_status_effects end #-------------------------------------------------------------------------- # * Update State Turn Count #-------------------------------------------------------------------------- #def update_state_turns # states.uniq.each do |state| # @state_turns[state.id] -= 1 if @state_turns[state.id] > 0 # end #end #-------------------------------------------------------------------------- # * [Add State] Effect #-------------------------------------------------------------------------- def item_effect_add_state(user, item, effect) if effect.data_id == 0 item_effect_add_state_attack(user, item, effect) else item_effect_add_state_normal(user, item, effect) end end #-------------------------------------------------------------------------- # * Add State #-------------------------------------------------------------------------- def add_state(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) return prp "add_state #{state_id} not found",1 if !state_id if state_addable?(state_id) ## Line below changed to allow stacking states. add_new_state(state_id) unless max_state_stack?(state_id) reset_state_counts(state_id) @result.added_states.push(state_id).uniq! end @stat_changed=true #verb req update LonaCHS and portrait end #-------------------------------------------------------------------------- # * Determine if States Are Addable #-------------------------------------------------------------------------- def state_addable?(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) #alive? && $data_states[state_id] && !state_resist?(state_id) && !state_restrict?(state_id) alive? && $data_states[state_id] && !state_restrict?(state_id) end #-------------------------------------------------------------------------- # * Determine States Removed During Same Action #-------------------------------------------------------------------------- def state_removed?(state_id) @result.removed_states.include?(state_id) end #-------------------------------------------------------------------------- # * Determine States Removed by Action Restriction #-------------------------------------------------------------------------- def state_restrict?(state_id) $data_states[state_id].remove_by_restriction && restriction > 0 end #-------------------------------------------------------------------------- # * Add New State #-------------------------------------------------------------------------- def add_new_state(state_id) state_id = $data_StateName[state_id].id if state_id.is_a?(String) return prp "add_new_state #{state_id} not found",1 if !state_id die if state_id == death_state_id @states.unshift(state_id) on_restrict if restriction > 0 sort_states refresh end # overwrite: states are sorted by their name color. def sort_states #sort_order = [:green, :yellow, :red, :magenta] #@states = @states.sort_by{|i| sort_order.index($data_states[i].color) || 999} end end