rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/Game_Actors.rb

@@ -0,0 +1,22 @@
+#==============================================================================
+# ** Game_Actors
+#------------------------------------------------------------------------------
+#  This is a wrapper for an actor array. Instances of this class are referenced
+# by $game_actors.
+#==============================================================================
+
+class Game_Actors
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    @data = []
+  end
+  #--------------------------------------------------------------------------
+  # * Get Actor
+  #--------------------------------------------------------------------------
+  def [](actor_id)
+    return nil unless $data_actors[actor_id]
+    @data[actor_id] ||= Game_Actor.new(actor_id)
+  end
+end

data/lib/rgss3_default_scripts/Game_BaseItem.rb

@@ -0,0 +1,51 @@
+#==============================================================================
+# ** Game_BaseItem
+#------------------------------------------------------------------------------
+#  This class uniformly handles skills, items, weapons, and armor. References
+# to the database object itself are not retained to enable inclusion in save
+# data.
+#==============================================================================
+
+class Game_BaseItem
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    @class = nil
+    @item_id = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Class
+  #--------------------------------------------------------------------------
+  def is_skill?;   @class == RPG::Skill;   end
+  def is_item?;    @class == RPG::Item;    end
+  def is_weapon?;  @class == RPG::Weapon;  end
+  def is_armor?;   @class == RPG::Armor;   end
+  def is_nil?;     @class == nil;          end
+  #--------------------------------------------------------------------------
+  # * Get Item Object
+  #--------------------------------------------------------------------------
+  def object
+    return $data_skills[@item_id]  if is_skill?
+    return $data_items[@item_id]   if is_item?
+    return $data_weapons[@item_id] if is_weapon?
+    return $data_armors[@item_id]  if is_armor?
+    return nil
+  end
+  #--------------------------------------------------------------------------
+  # * Set Item Object
+  #--------------------------------------------------------------------------
+  def object=(item)
+    @class = item ? item.class : nil
+    @item_id = item ? item.id : 0
+  end
+  #--------------------------------------------------------------------------
+  # * Set Equipment with ID
+  #     is_weapon:  Whether it is a weapon
+  #     item_id: Weapon/armor ID
+  #--------------------------------------------------------------------------
+  def set_equip(is_weapon, item_id)
+    @class = is_weapon ? RPG::Weapon : RPG::Armor
+    @item_id = item_id
+  end
+end

data/lib/rgss3_default_scripts/Game_Battler.rb

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