852 lines
36 KiB
Ruby
852 lines
36 KiB
Ruby
#==============================================================================
|
|
# ** Game_BattlerBase
|
|
#------------------------------------------------------------------------------
|
|
# This base class handles battlers. It mainly contains methods for calculating
|
|
# parameters. It is used as a super class of the Game_Battler class.
|
|
#==============================================================================
|
|
|
|
class Game_BattlerBase
|
|
#--------------------------------------------------------------------------
|
|
# * Constants (Features)
|
|
#--------------------------------------------------------------------------
|
|
FEATURE_ELEMENT_RATE = 11 # Element Rate
|
|
FEATURE_DEBUFF_RATE = 12 # Debuff Rate
|
|
FEATURE_STATE_RATE = 13 # State Rate
|
|
FEATURE_STATE_RESIST = 14 # State Resist
|
|
FEATURE_PARAM = 21 # Parameter
|
|
FEATURE_XPARAM = 22 # Ex-Parameter
|
|
FEATURE_SPARAM = 23 # Sp-Parameter
|
|
FEATURE_ATK_ELEMENT = 31 # Atk Element
|
|
FEATURE_ATK_STATE = 32 # Atk State
|
|
FEATURE_ATK_SPEED = 33 # Atk Speed
|
|
FEATURE_ATK_TIMES = 34 # Atk Times+
|
|
FEATURE_STYPE_ADD = 41 # Add Skill Type
|
|
FEATURE_STYPE_SEAL = 42 # Disable Skill Type
|
|
FEATURE_SKILL_ADD = 43 # Add Skill
|
|
FEATURE_SKILL_SEAL = 44 # Disable Skill
|
|
FEATURE_EQUIP_WTYPE = 51 # Equip Weapon
|
|
FEATURE_EQUIP_ATYPE = 52 # Equip Armor
|
|
FEATURE_EQUIP_FIX = 53 # Lock Equip
|
|
FEATURE_EQUIP_SEAL = 54 # Seal Equip
|
|
FEATURE_SLOT_TYPE = 55 # Slot Type
|
|
FEATURE_ACTION_PLUS = 61 # Action Times+
|
|
FEATURE_SPECIAL_FLAG = 62 # Special Flag
|
|
FEATURE_COLLAPSE_TYPE = 63 # Collapse Effect
|
|
FEATURE_PARTY_ABILITY = 64 # Party Ability
|
|
#--------------------------------------------------------------------------
|
|
# * Constants (Feature Flags)
|
|
#--------------------------------------------------------------------------
|
|
FLAG_ID_AUTO_BATTLE = 0 # auto battle
|
|
FLAG_ID_GUARD = 1 # guard
|
|
FLAG_ID_SUBSTITUTE = 2 # substitute
|
|
FLAG_ID_PRESERVE_TP = 3 # preserve TP
|
|
#--------------------------------------------------------------------------
|
|
# * Constants (Starting Number of Buff/Debuff Icons)
|
|
#--------------------------------------------------------------------------
|
|
ICON_BUFF_START = 64 # buff (16 icons)
|
|
ICON_DEBUFF_START = 80 # debuff (16 icons)
|
|
#--------------------------------------------------------------------------
|
|
# * Public Instance Variables
|
|
#--------------------------------------------------------------------------
|
|
#attr_reader :hp # HP
|
|
#attr_reader :mp # MP
|
|
#attr_reader :tp # TP
|
|
#--------------------------------------------------------------------------
|
|
# * Access Method by Parameter Abbreviations
|
|
#--------------------------------------------------------------------------
|
|
#def mhp; param(0); end # MHP Maximum Hit Points
|
|
#def mmp; param(1); end # MMP Maximum Magic Points
|
|
#def atk; param(2); end # ATK ATtacK power
|
|
#def def; param(3); end # DEF DEFense power
|
|
#def mat; param(4); end # MAT Magic ATtack power
|
|
#def mdf; param(5); end # MDF Magic DeFense power
|
|
#def agi; param(6); end # AGI AGIlity
|
|
#def luk; param(7); end # LUK LUcK
|
|
#def hit; xparam(0); end # HIT HIT rate
|
|
#def eva; xparam(1); end # EVA EVAsion rate
|
|
#def cri; xparam(2); end # CRI CRItical rate
|
|
#def cev; xparam(3); end # CEV Critical EVasion rate
|
|
#def mev; xparam(4); end # MEV Magic EVasion rate
|
|
#def mrf; xparam(5); end # MRF Magic ReFlection rate
|
|
#def cnt; xparam(6); end # CNT CouNTer attack rate
|
|
#def hrg; xparam(7); end # HRG Hp ReGeneration rate
|
|
#def mrg; xparam(8); end # MRG Mp ReGeneration rate
|
|
#def trg; xparam(9); end # TRG Tp ReGeneration rate
|
|
#def tgr; sparam(0); end # TGR TarGet Rate
|
|
#def grd; sparam(1); end # GRD GuaRD effect rate
|
|
#def rec; sparam(2); end # REC RECovery effect rate
|
|
#def pha; sparam(3); end # PHA PHArmacology
|
|
#def mcr; sparam(4); end # MCR Mp Cost Rate
|
|
#def tcr; sparam(5); end # TCR Tp Charge Rate
|
|
#def pdr; sparam(6); end # PDR Physical Damage Rate
|
|
#def mdr; sparam(7); end # MDR Magical Damage Rate
|
|
#def fdr; sparam(8); end # FDR Floor Damage Rate
|
|
#def exr; sparam(9); end # EXR EXperience Rate
|
|
#--------------------------------------------------------------------------
|
|
# * Object Initialization
|
|
#--------------------------------------------------------------------------
|
|
def initialize
|
|
#@hp = @mp = @tp = 0
|
|
@hidden = false
|
|
clear_param_plus
|
|
clear_states
|
|
clear_buffs
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Clear Values Added to Parameter
|
|
#--------------------------------------------------------------------------
|
|
def clear_param_plus
|
|
@param_plus = [0] * 8
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Clear State Information
|
|
#--------------------------------------------------------------------------
|
|
def clear_states
|
|
@states = []
|
|
#@state_turns = {}
|
|
@state_steps = {}
|
|
@state_frames= {}
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Erase States
|
|
#--------------------------------------------------------------------------
|
|
def erase_state(state_id)
|
|
state_id = $data_StateName[state_id].id if state_id.is_a?(String)
|
|
return prp "erase_state #{state_id} not found",1 if !state_id
|
|
@states -= [state_id] ## Line added to remove only one instance.
|
|
return if state?(state_id) ## Line added to prevent a stack from bugging.
|
|
#@state_turns.delete(state_id)
|
|
@state_steps.delete(state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Clear Buff Information
|
|
#--------------------------------------------------------------------------
|
|
def clear_buffs
|
|
@buffs = Array.new(8) { 0 }
|
|
@buff_turns = {}
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Check State
|
|
#--------------------------------------------------------------------------
|
|
def state?(state_id)
|
|
@states.include?(state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Check K.O. State
|
|
#--------------------------------------------------------------------------
|
|
def death_state?
|
|
state?(death_state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get State ID of K.O.
|
|
#--------------------------------------------------------------------------
|
|
def death_state_id
|
|
return 1
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Current States as an Object Array
|
|
#--------------------------------------------------------------------------
|
|
def states
|
|
@states.collect {|id| $data_states[id] }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Current States as an Array of Icon Numbers
|
|
#--------------------------------------------------------------------------
|
|
#def state_icons
|
|
# icons = states.collect {|state| state.icon_index }
|
|
# icons.delete(0)
|
|
# icons
|
|
#end
|
|
|
|
def state_icons ## "uniq" method added and "icon_index" changed.
|
|
icons = states.uniq.collect {|state| state.icon_index(state_stack(state.id)) }
|
|
icons.delete(0)
|
|
icons
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Current Buffs/Debuffs as an Array of Icon Numbers
|
|
#--------------------------------------------------------------------------
|
|
#def buff_icons
|
|
# icons = []
|
|
# @buffs.each_with_index {|lv, i| icons.push(buff_icon_index(lv, i)) }
|
|
# icons.delete(0)
|
|
# icons
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Icon Number Corresponding to Buff/Debuff
|
|
#--------------------------------------------------------------------------
|
|
#def buff_icon_index(buff_level, param_id)
|
|
# if buff_level > 0
|
|
# return ICON_BUFF_START + (buff_level - 1) * 8 + param_id
|
|
# elsif buff_level < 0
|
|
# return ICON_DEBUFF_START + (-buff_level - 1) * 8 + param_id
|
|
# else
|
|
# return 0
|
|
# end
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Array of All Objects Retaining Features
|
|
#--------------------------------------------------------------------------
|
|
def feature_objects
|
|
states
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Array of All Feature Objects
|
|
#--------------------------------------------------------------------------
|
|
# def all_features
|
|
# #feature_objects.inject([]) {|r, obj| r + obj.features }
|
|
# []
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Get Feature Object Array (Feature Codes Limited)
|
|
# #--------------------------------------------------------------------------
|
|
# def features(code)
|
|
# all_features.select {|ft| ft.code == code }
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Get Feature Object Array (Feature Codes and Data IDs Limited)
|
|
# #--------------------------------------------------------------------------
|
|
# def features_with_id(code, id)
|
|
# all_features.select {|ft| ft.code == code && ft.data_id == id }
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Calculate Complement of Feature Values
|
|
# #--------------------------------------------------------------------------
|
|
# def features_pi(code, id)
|
|
# features_with_id(code, id).inject(1.0) {|r, ft| r *= ft.value }
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Calculate Sum of Feature Values (Specify Data ID)
|
|
# #--------------------------------------------------------------------------
|
|
# def features_sum(code, id)
|
|
# features_with_id(code, id).inject(0.0) {|r, ft| r += ft.value }
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Calculate Sum of Feature Values (Data ID Unspecified)
|
|
# #--------------------------------------------------------------------------
|
|
# def features_sum_all(code)
|
|
# features(code).inject(0.0) {|r, ft| r += ft.value }
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Calculate Set Sum of Features
|
|
# #--------------------------------------------------------------------------
|
|
# def features_set(code)
|
|
# features(code).inject([]) {|r, ft| r |= [ft.data_id] }
|
|
# end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Base Value of Parameter
|
|
#--------------------------------------------------------------------------
|
|
def param_base(param_id)
|
|
return 0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Added Value of Parameter
|
|
#--------------------------------------------------------------------------
|
|
def param_plus(param_id)
|
|
@param_plus[param_id]
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Reduced Value of Parameter
|
|
#--------------------------------------------------------------------------
|
|
def param_min(param_id)
|
|
return 0 if param_id == 1 # MMP
|
|
return 1
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Maximum Value of Parameter
|
|
#--------------------------------------------------------------------------
|
|
def param_max(param_id)
|
|
return 999999 if param_id == 0 # MHP
|
|
return 9999 if param_id == 1 # MMP
|
|
return 999
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Rate of Parameter Change
|
|
#--------------------------------------------------------------------------
|
|
def param_rate(param_id)
|
|
#features_pi(FEATURE_PARAM, param_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Rate of Change Due to Parameter Buff/Debuff
|
|
#--------------------------------------------------------------------------
|
|
def param_buff_rate(param_id)
|
|
@buffs[param_id] * 0.25 + 1.0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Parameter
|
|
#--------------------------------------------------------------------------
|
|
def param(param_id)
|
|
value = param_base(param_id) + param_plus(param_id)
|
|
value *= param_rate(param_id) * param_buff_rate(param_id)
|
|
[[value, param_max(param_id)].min, param_min(param_id)].max.to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Ex-Parameter
|
|
#--------------------------------------------------------------------------
|
|
def xparam(xparam_id)
|
|
# features_sum(FEATURE_XPARAM, xparam_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Sp-Parameter
|
|
#--------------------------------------------------------------------------
|
|
def sparam(sparam_id)
|
|
# features_pi(FEATURE_SPARAM, sparam_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Element Rate
|
|
#--------------------------------------------------------------------------
|
|
def element_rate(element_id)
|
|
#features_pi(FEATURE_ELEMENT_RATE, element_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Debuff Rate
|
|
#--------------------------------------------------------------------------
|
|
def debuff_rate(param_id)
|
|
# features_pi(FEATURE_DEBUFF_RATE, param_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get State Rate
|
|
#--------------------------------------------------------------------------
|
|
def state_rate(state_id)
|
|
#features_pi(FEATURE_STATE_RATE, state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Array of States to Resist
|
|
#--------------------------------------------------------------------------
|
|
def state_resist_set
|
|
#features_set(FEATURE_STATE_RESIST)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if State Is Resisted
|
|
#--------------------------------------------------------------------------
|
|
def state_resist?(state_id)
|
|
state_resist_set.include?(state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Attack Element
|
|
#--------------------------------------------------------------------------
|
|
def atk_elements
|
|
#features_set(FEATURE_ATK_ELEMENT)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Attack State
|
|
#--------------------------------------------------------------------------
|
|
def atk_states
|
|
#features_set(FEATURE_ATK_STATE)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Attack State Invocation Rate
|
|
#--------------------------------------------------------------------------
|
|
def atk_states_rate(state_id)
|
|
#features_sum(FEATURE_ATK_STATE, state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Attack Speed
|
|
#--------------------------------------------------------------------------
|
|
def atk_speed
|
|
#features_sum_all(FEATURE_ATK_SPEED)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Additional Attack Times
|
|
#--------------------------------------------------------------------------
|
|
def atk_times_add
|
|
# [features_sum_all(FEATURE_ATK_TIMES), 0].max
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Added Skill Types
|
|
#--------------------------------------------------------------------------
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Skill Type Is Disabled
|
|
#--------------------------------------------------------------------------
|
|
#--------------------------------------------------------------------------
|
|
# * Get Added Skills
|
|
#--------------------------------------------------------------------------
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Weapon Can Be Equipped
|
|
#--------------------------------------------------------------------------
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Equipment Is Locked Sealed
|
|
#--------------------------------------------------------------------------
|
|
def equip_slot_fixed_hard?(etype_id)
|
|
etype_id = $data_system.equip_type_name[etype_id] if etype_id.is_a?(String)
|
|
return true if fixed_hard_etypes.include?(etype_id) if actor?
|
|
return false
|
|
end
|
|
def equip_slot_fixed?(etype_id)
|
|
etype_id = $data_system.equip_type_name[etype_id] if etype_id.is_a?(String)
|
|
return true if fixed_etypes.include?(etype_id) if actor?
|
|
return false
|
|
#features_set(FEATURE_EQUIP_FIX).include?(etype_id)
|
|
end
|
|
def equip_slot_sealed?(etype_id)
|
|
etype_id = $data_system.equip_type_name[etype_id] if etype_id.is_a?(String)
|
|
return true if sealed_etypes.include?(etype_id) if actor?
|
|
return false
|
|
#features_set(FEATURE_EQUIP_SEAL).include?(etype_id)
|
|
end
|
|
def wtype_sealed?(wtype_id)
|
|
feature_objects.uniq.each { |o| return true if o.wtype_seal.include?(wtype_id) }
|
|
return false
|
|
end
|
|
def atype_sealed?(atype_id)
|
|
feature_objects.uniq.each { |o| return true if o.atype_seal.include?(atype_id) }
|
|
return false
|
|
end
|
|
def equip_wtype_ok?(wtype_id)
|
|
feature_objects.uniq.each { |o| return true if o.wtype_okay(wtype_id) }
|
|
return false
|
|
#features_set(FEATURE_EQUIP_WTYPE).include?(wtype_id)
|
|
end
|
|
|
|
def equip_atype_ok?(atype_id)
|
|
feature_objects.uniq.each { |o| return true if o.atype_okay(atype_id) }
|
|
return false
|
|
#features_set(FEATURE_EQUIP_ATYPE).include?(atype_id)
|
|
end
|
|
def skill_type_sealed?(stype_id)
|
|
# features_set(FEATURE_STYPE_SEAL).include?(stype_id)
|
|
false
|
|
end
|
|
def added_skill_types
|
|
#features_set(FEATURE_STYPE_ADD)
|
|
end
|
|
def added_skills
|
|
tmpAry = []
|
|
feature_objects.uniq.each { |o|
|
|
tmpAry = tmpAry | o.added_skills
|
|
}
|
|
tmpAry
|
|
#features_set(FEATURE_SKILL_ADD)
|
|
end
|
|
def skill_sealed?(skill_id)
|
|
return feature_objects.uniq.any?{|o| o.skill_sealed.include?(skill_id)}
|
|
#features_set(FEATURE_SKILL_SEAL).include?(skill_id)
|
|
end
|
|
def equippable?(item)
|
|
return false unless equippable_lv1_chk?(item)
|
|
return false if item.is_a?(RPG::Weapon) && wtype_sealed?(item.wtype_id)
|
|
return false if item.is_a?(RPG::Armor) && atype_sealed?(item.atype_id)
|
|
return true
|
|
end
|
|
|
|
def equippable_lv1_chk?(item)
|
|
return false unless item && item.etype_id
|
|
return false if equip_slot_sealed?(item.etype_id)
|
|
return equip_wtype_ok?(item.wtype_id) if item.wtype_id
|
|
return equip_atype_ok?(item.atype_id) if item.atype_id
|
|
return false
|
|
end
|
|
|
|
def common_equippable?(item)
|
|
return false if !equippable?(item)
|
|
return false if equip_slot_sealed?(item.etype_id)
|
|
return false if equip_slot_fixed?(item.etype_id)
|
|
true
|
|
end
|
|
def common_unequippable?(slot)
|
|
slot = $data_system.equip_type_name[slot] if slot.is_a?(String)
|
|
return false if equip_slot_sealed?(slot)
|
|
return false if equip_slot_fixed?(slot)
|
|
true
|
|
end
|
|
|
|
#will report [equip_slot] if its sealed or fixed ur item. EQUIP SLOT ONLY
|
|
#when return [] mean fully equippable?
|
|
#when ![].empty? array mean blocked by something
|
|
#when false mean not possible cant equip
|
|
def report_reverse_equippable(item)
|
|
return false if item.etype_id.nil?
|
|
tgt_slot = item.etype_id
|
|
finalReport = []
|
|
feature_objects.uniq.each {|tmp_F_OBJ|
|
|
next unless tmp_F_OBJ
|
|
next if tmp_F_OBJ.is_a?(RPG::Actor)
|
|
next if tmp_F_OBJ.is_a?(RPG::Class)
|
|
next unless !tmp_F_OBJ.fixed_equip_type.empty? || !tmp_F_OBJ.sealed_equip_type.empty? || !tmp_F_OBJ.wtype_seal.empty? || !tmp_F_OBJ.atype_seal.empty?
|
|
next unless tmp_F_OBJ.fixed_equip_type.include?(tgt_slot) || tmp_F_OBJ.sealed_equip_type.include?(tgt_slot) || tmp_F_OBJ.wtype_seal.include?(item.wtype_id) || tmp_F_OBJ.atype_seal.include?(item.atype_id)
|
|
if tmp_F_OBJ.is_a?(RPG::State)
|
|
return false if tmp_F_OBJ.fixed_equip_type.include?(tgt_slot)
|
|
return false if tmp_F_OBJ.sealed_equip_type.include?(tgt_slot)
|
|
return false if tmp_F_OBJ.wtype_seal.include?(item.wtype_id)
|
|
return false if tmp_F_OBJ.atype_seal.include?(item.atype_id)
|
|
end
|
|
next unless tmp_F_OBJ.etype_id
|
|
#next unless common_unequippable?(tmp_F_OBJ.etype_id)
|
|
return false if !common_unequippable?(tmp_F_OBJ.etype_id)
|
|
finalReport << tmp_F_OBJ.etype_id
|
|
}
|
|
finalReport << tgt_slot if self.equips[tgt_slot] # insert self is theres
|
|
return false if !finalReport
|
|
finalReport.uniq
|
|
end
|
|
def report_reverse_unequip_by(item)
|
|
finalReport = []
|
|
item.sealed_equip_type.each{|slot|
|
|
next unless self.equips[slot]
|
|
finalReport << slot
|
|
}
|
|
item.wtype_seal.each{|slot|
|
|
next unless self.equips[slot] && item.wtype_seal.include?(self.equips[slot].wtype_id)
|
|
finalReport << slot
|
|
}
|
|
item.atype_seal.each{|slot|
|
|
next unless self.equips[slot] && item.atype_seal.include?(self.equips[slot].atype_id)
|
|
finalReport << slot
|
|
}
|
|
finalReport.uniq
|
|
end
|
|
|
|
#@stats_key = stats_key
|
|
#@stats_value = stats_value
|
|
#@stats_filter = stats_filter
|
|
def effect_allowed?(le)
|
|
if !le.stats_key.nil?
|
|
if le.stats_filter
|
|
return le.stats_value.include?(self.stat[le.stats_key])
|
|
else
|
|
return !le.stats_value.include?(self.stat[le.stats_key])
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Slot Type
|
|
#--------------------------------------------------------------------------
|
|
# def slot_type
|
|
# #features_set(FEATURE_SLOT_TYPE).max || 0
|
|
# 0
|
|
# end
|
|
# #--------------------------------------------------------------------------
|
|
# # * Determine if Dual Wield
|
|
# #--------------------------------------------------------------------------
|
|
# def dual_wield?
|
|
# #slot_type == 1
|
|
# false
|
|
# end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Array of Additional Action Time Probabilities
|
|
#--------------------------------------------------------------------------
|
|
def action_plus_set
|
|
features(FEATURE_ACTION_PLUS).collect {|ft| ft.value }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Special Flag
|
|
#--------------------------------------------------------------------------
|
|
def special_flag(flag_id)
|
|
features(FEATURE_SPECIAL_FLAG).any? {|ft| ft.data_id == flag_id }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Collapse Effect
|
|
#--------------------------------------------------------------------------
|
|
def collapse_type
|
|
features_set(FEATURE_COLLAPSE_TYPE).max || 0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Party Ability
|
|
#--------------------------------------------------------------------------
|
|
def party_ability(ability_id)
|
|
features(FEATURE_PARTY_ABILITY).any? {|ft| ft.data_id == ability_id }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Auto Battle
|
|
#--------------------------------------------------------------------------
|
|
def auto_battle?
|
|
special_flag(FLAG_ID_AUTO_BATTLE)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Guard
|
|
#--------------------------------------------------------------------------
|
|
def guard?
|
|
special_flag(FLAG_ID_GUARD) && movable?
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Substitute
|
|
#--------------------------------------------------------------------------
|
|
def substitute?
|
|
special_flag(FLAG_ID_SUBSTITUTE) && movable?
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Preserve TP
|
|
#--------------------------------------------------------------------------
|
|
def preserve_tp?
|
|
special_flag(FLAG_ID_PRESERVE_TP)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Increase Parameter
|
|
#--------------------------------------------------------------------------
|
|
def add_param(param_id, value)
|
|
@param_plus[param_id] += value
|
|
refresh
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Change HP
|
|
#--------------------------------------------------------------------------
|
|
def hp=(hp)
|
|
@hp = hp
|
|
refresh
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Change MP
|
|
#--------------------------------------------------------------------------
|
|
def mp=(mp)
|
|
@mp = mp
|
|
refresh
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Change HP (for Events)
|
|
# value: Amount of increase/decrease
|
|
# enable_death: Allow knockout
|
|
#--------------------------------------------------------------------------
|
|
def change_hp(value, enable_death)
|
|
if !enable_death && @hp + value <= 0
|
|
self.hp = 1
|
|
else
|
|
self.hp += value
|
|
end
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Change TP
|
|
#--------------------------------------------------------------------------
|
|
def tp=(tp)
|
|
@tp = [[tp, max_tp].min, 0].max
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Maximum Value of TP
|
|
#--------------------------------------------------------------------------
|
|
def max_tp
|
|
return 100
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Refresh
|
|
#--------------------------------------------------------------------------
|
|
def refresh
|
|
#state_resist_set.each {|state_id| erase_state(state_id) }
|
|
#@hp = [[@hp, mhp].min, 0].max
|
|
#@mp = [[@mp, mmp].min, 0].max
|
|
#@hp == 0 ? add_state(death_state_id) : remove_state(death_state_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Recover All
|
|
#--------------------------------------------------------------------------
|
|
def recover_all
|
|
clear_states
|
|
#@hp = mhp
|
|
#@mp = mmp
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Percentage of HP
|
|
#--------------------------------------------------------------------------
|
|
#def hp_rate
|
|
# @hp.to_f / mhp
|
|
#end
|
|
##--------------------------------------------------------------------------
|
|
## * Get Percentage of MP
|
|
##--------------------------------------------------------------------------
|
|
#def mp_rate
|
|
# mmp > 0 ? @mp.to_f / mmp : 0
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Percentage of TP
|
|
#--------------------------------------------------------------------------
|
|
def tp_rate
|
|
@tp.to_f / 100
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Hide
|
|
#--------------------------------------------------------------------------
|
|
def hide
|
|
@hidden = true
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Appear
|
|
#--------------------------------------------------------------------------
|
|
def appear
|
|
@hidden = false
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Hide State
|
|
#--------------------------------------------------------------------------
|
|
def hidden?
|
|
@hidden
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Existence
|
|
#--------------------------------------------------------------------------
|
|
def exist?
|
|
!hidden?
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Incapacitation
|
|
#--------------------------------------------------------------------------
|
|
def dead?
|
|
exist? && death_state?
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Survival
|
|
#--------------------------------------------------------------------------
|
|
def alive?
|
|
exist? && !death_state?
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Normality
|
|
#--------------------------------------------------------------------------
|
|
def normal?
|
|
exist? && restriction == 0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Command is Inputable
|
|
#--------------------------------------------------------------------------
|
|
#def inputable?
|
|
# normal? && !auto_battle?
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Action is Possible
|
|
#--------------------------------------------------------------------------
|
|
def movable?
|
|
exist? && restriction < 4
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Character is Confused
|
|
#--------------------------------------------------------------------------
|
|
def confusion?
|
|
exist? && restriction >= 1 && restriction <= 3
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Confusion Level
|
|
#--------------------------------------------------------------------------
|
|
def confusion_level
|
|
confusion? ? restriction : 0
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Actor or Not
|
|
#--------------------------------------------------------------------------
|
|
def actor?
|
|
return false
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Enemy
|
|
#--------------------------------------------------------------------------
|
|
def enemy?
|
|
return false
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Sorting States
|
|
# Sort the content of the @states array, with higher priority states
|
|
# coming first.
|
|
#--------------------------------------------------------------------------
|
|
def sort_states
|
|
@states = @states.sort_by {|id| [-$data_states[id].priority, id] }
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Restriction
|
|
# Get the largest restriction from the currently added states.
|
|
#--------------------------------------------------------------------------
|
|
def restriction
|
|
states.collect {|state| state.restriction }.push(0).max
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Most Important State Continuation Message
|
|
#--------------------------------------------------------------------------
|
|
#def most_important_state_text
|
|
# states.each {|state| return state.message3 unless state.message3.empty? }
|
|
# return ""
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Skill-Required Weapon Is Equipped
|
|
#--------------------------------------------------------------------------
|
|
def skill_wtype_ok?(skill)
|
|
return true
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Calculate Skill's MP Cost
|
|
#--------------------------------------------------------------------------
|
|
def skill_mp_cost(skill)
|
|
(skill.mp_cost * mcr).to_i
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Calculate Skill's TP Cost
|
|
#--------------------------------------------------------------------------
|
|
def skill_tp_cost(skill)
|
|
skill.tp_cost
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Cost of Using Skill Can Be Paid
|
|
#--------------------------------------------------------------------------
|
|
#def skill_cost_payable?(skill)
|
|
# tp >= skill_tp_cost(skill) && mp >= skill_mp_cost(skill)
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Pay Cost of Using Skill
|
|
#--------------------------------------------------------------------------
|
|
def pay_skill_cost(skill)
|
|
self.mp -= skill_mp_cost(skill)
|
|
self.tp -= skill_tp_cost(skill)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Check When Skill/Item Can Be Used
|
|
#--------------------------------------------------------------------------
|
|
#def occasion_ok?(item)
|
|
# $game_party.in_battle ? item.battle_ok? : item.menu_ok?
|
|
#end
|
|
#--------------------------------------------------------------------------
|
|
# * Check Common Usability Conditions for Skill/Item
|
|
#--------------------------------------------------------------------------
|
|
def usable_item_conditions_met?(item)
|
|
movable? #&& occasion_ok?(item)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Check Usability Conditions for Skill
|
|
#--------------------------------------------------------------------------
|
|
def skill_conditions_met?(skill)
|
|
usable_item_conditions_met?(skill) &&
|
|
!skill_sealed?(skill.id) && !skill_type_sealed?(skill.stype_id)
|
|
#skill_wtype_ok?(skill) && !skill_sealed?(skill.id) && !skill_type_sealed?(skill.stype_id)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Check Usability Conditions for Item
|
|
#--------------------------------------------------------------------------
|
|
def item_conditions_met?(item)
|
|
usable_item_conditions_met?(item) && $game_party.has_item?(item)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Skill/Item Usability
|
|
#--------------------------------------------------------------------------
|
|
def usable?(item)
|
|
return skill_conditions_met?(item) if item.is_a?(RPG::Skill)
|
|
return false if !item.consumable
|
|
return true if item.consumable
|
|
return item_conditions_met?(item) if item.is_a?(RPG::Item)
|
|
#return item_conditions_met?(item) if item.is_a?(RPG::Armor)
|
|
#return item_conditions_met?(item) if item.is_a?(RPG::Weapon)
|
|
return false
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine if Equippable
|
|
#--------------------------------------------------------------------------
|
|
#--------------------------------------------------------------------------
|
|
# * Get Skill ID of Normal Attack
|
|
#--------------------------------------------------------------------------
|
|
def attack_skill_id
|
|
return 1
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Get Skill ID of Guard
|
|
#--------------------------------------------------------------------------
|
|
def guard_skill_id
|
|
return 2
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Usability of Normal Attack
|
|
#--------------------------------------------------------------------------
|
|
def attack_usable?
|
|
usable?($data_skills[attack_skill_id])
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# * Determine Usability of Guard
|
|
#--------------------------------------------------------------------------
|
|
def guard_usable?
|
|
usable?($data_skills[guard_skill_id])
|
|
end
|
|
end
|