Initial import
This commit is contained in:
825
Scripts/RPG/Game_Battler.rb
Normal file
825
Scripts/RPG/Game_Battler.rb
Normal file
@@ -0,0 +1,825 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#==============================================================================
|
||||
# ** 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
|
||||
#--------------------------------------------------------------------------
|
||||
# * Clear State Information
|
||||
#--------------------------------------------------------------------------
|
||||
def clear_states
|
||||
super
|
||||
@result.clear_status_effects
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Add State
|
||||
#--------------------------------------------------------------------------
|
||||
def add_state(state_id)
|
||||
if state_addable?(state_id)
|
||||
add_new_state(state_id) unless state?(state_id)
|
||||
reset_state_counts(state_id)
|
||||
@result.added_states.push(state_id).uniq!
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine if States Are Addable
|
||||
#--------------------------------------------------------------------------
|
||||
def state_addable?(state_id)
|
||||
alive? && $data_states[state_id] && !state_resist?(state_id) &&
|
||||
!state_removed?(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)
|
||||
die if state_id == death_state_id
|
||||
@states.push(state_id)
|
||||
on_restrict if restriction > 0
|
||||
sort_states
|
||||
refresh
|
||||
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 = $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
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Remove State
|
||||
#--------------------------------------------------------------------------
|
||||
def remove_state(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 State Turn Count
|
||||
#--------------------------------------------------------------------------
|
||||
def update_state_turns
|
||||
states.each do |state|
|
||||
@state_turns[state.id] -= 1 if @state_turns[state.id] > 0
|
||||
end
|
||||
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.is_a?(RPG::Item)
|
||||
item.effects.each {|effect| item_global_effect_apply(effect) }
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Consume Items
|
||||
#--------------------------------------------------------------------------
|
||||
def consume_item(item)
|
||||
$game_party.consume_item(item)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Apply Effect of Use to Other Than User
|
||||
#--------------------------------------------------------------------------
|
||||
def item_global_effect_apply(effect)
|
||||
if effect.code == EFFECT_COMMON_EVENT
|
||||
$game_temp.reserve_common_event(effect.data_id)
|
||||
end
|
||||
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?(effect.data_id)
|
||||
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
|
||||
#--------------------------------------------------------------------------
|
||||
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] 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
|
||||
#--------------------------------------------------------------------------
|
||||
def item_effect_remove_state(user, item, effect)
|
||||
chance = effect.value1
|
||||
if rand < chance
|
||||
remove_state(effect.data_id)
|
||||
@result.success = true
|
||||
end
|
||||
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_battle_states
|
||||
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
|
||||
end
|
||||
Reference in New Issue
Block a user