# ▼▲▼ XRXS19. 特殊効果詰め合わせ DamageEX ver.1.9 ▼▲▼ built 220920
# by 桜雅 在土 (基本)
#    Tetra-Z   (修正)

#==============================================================================
# □ カスタマイズポイント
#==============================================================================
module XRXS19
  DE_MERIT          = false                # デメリットを認めるか
  VARY_BASE         = 256                  # 乱数の基準値(分の1)
  ATTACK_VARY       = 16                   # 通常攻撃の乱数幅
  DAMAGE_LIMIT      = 65535                # 限界ダメージの絶対値
  HPSP_DAMAGE       = "HP&SPダメージ"      # 「　  HP&SPダメージ  　」属性の名前
  CRITICAL_PLUS     = "必殺強化"           # 「　  必殺強化  　」属性の名前
  ATTACK            = "物理"               # 「　  物理  　」属性の名前
  MAGIC             = "魔法"               # 「　  魔法  　」属性の名前
  ATTACK_SEAL       = "物理封じ"           # 「　  物理封じ  　」属性の名前
  MAGIC_SEAL        = "魔法封じ"           # 「　  魔法封じ  　」属性の名前
  NOT_SHOCK         = "非衝撃"             # 「　  非衝撃  　」属性の名前
  HIT               = "命中"               # 「　 命中強化 　」属性の名前
  GUARD_BREAK       = "防御無視"           # 「　 防御無視 　」属性の名前
end
module Numset
  # 空でも使えるものは使える。
end
#==============================================================================
# ■ Game_BattleAction
#==============================================================================
class Game_BattleAction
  #==============================================================================
  # ○ 公開インスタンス変数
  #==============================================================================
  attr_accessor :sp_damage                # 「SPダメージ」  (Numeric)
  attr_accessor :hpsp_damage              # 「HP&SPダメージ」(true/false)
  attr_accessor :critical_plus            # 「必殺強化」    (Numeric)
  attr_accessor :not_shock                # 「睡眠非解除」  (true/false)
  attr_accessor :hit_plus                 # 「命中補正」   （Numeric)
  attr_accessor :guard_break              # 「防御無視」    (true/false)
  #--------------------------------------------------------------------------
  # ○ 特殊効果を初期化
  #--------------------------------------------------------------------------
  alias :base_initialize_xrxs19_special_effect :initialize_xrxs19_special_effect
  def initialize_xrxs19_special_effect
    base_initialize_xrxs19_special_effect
    self.sp_damage = 0
    self.hpsp_damage = false
    self.critical_plus = 0
    self.not_shock = false
    self.hit_plus = 0
    self.guard_break = false
  end
  #--------------------------------------------------------------------------
  # ○ 特殊効果の設定
  #--------------------------------------------------------------------------
  alias :base_set_xrxs19_special_effect :set_xrxs19_special_effect
  def set_xrxs19_special_effect(set)
    base_set_xrxs19_special_effect(set)
    # 必殺 ([数値, 数値%])
    self.critical_hit = [XRXS.element_amount(set, XRXS19::CRITICAL_HIT), XRXS.element_percent(set, XRXS19::CRITICAL_HIT)]
    # SPダメージ (数値%)
    self.sp_damage = XRXS.element_percent(set, XRXS19::SP_DAMAGE)
    # HP&SPダメージ (true/false)
    self.hpsp_damage = XRXS.element_include?(set, XRXS19::HPSP_DAMAGE)
    # 必殺強化 (数値%)
    self.critical_plus = XRXS.element_percent(set, XRXS19::CRITICAL_PLUS)
    # 睡眠非解除 (true/false)
    self.not_shock = XRXS.element_include?(set, XRXS19::NOT_SHOCK)
    # 命中強化 (数値%)
    self.hit_plus = XRXS.element_percent(set, XRXS19::CRITICAL_PLUS)
    # 防御無視 (true/false)
    self.guard_break = XRXS.element_include?(set, XRXS19::GUARD_BREAK)
  end
  #--------------------------------------------------------------------------
  # ○ 特殊効果をクリア
  #--------------------------------------------------------------------------
  alias :base_clear_xrxs19_special_effect :clear_xrxs19_special_effect
  def clear_xrxs19_special_effect
    base_clear_xrxs19_special_effect
    self.critical_plus = nil
    self.hpsp_damage = nil
    self.not_shock = nil
    self.hit_plus = nil
  end
end

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● スキルの使用可能判定
  #     skill_id : スキル ID
  #--------------------------------------------------------------------------
  def skill_can_use?(skill_id)
    # SP が足りない場合は使用不可
    skill = $data_skills[skill_id]
    if skill.sp_cost > self.sp
      return false
    end
    # 戦闘不能の場合は使用不可
    if dead?
      return false
    end
    # 物理封じ状態の場合、物理スキルは使用不可
    if self.restriction == 1
      if XRXS.element_include?(skill.element_set, XRXS19::ATTACK)
        @states.each{|state| i = state.guard_element_set
        if XRXS.element_include?(i, XRXS19::ATTACK_SEAL)
          return false
        end
        }
      # 魔法封じ状態の場合、魔法スキルは使用不可
      elsif XRXS.element_include?(skill.element_set, XRXS19::MAGIC)
        @states.each{|state| i = state.guard_element_set
        if XRXS.element_include?(i, XRXS19::MAGIC_SEAL)
          return false
        end
        }
      end
    end
    # 使用可能時を取得
    occasion = skill.occasion
    # 戦闘中の場合
    if $game_temp.in_battle
      # [常時] または [バトルのみ] なら使用可
      return (occasion == 0 or occasion == 1)
    # 戦闘中ではない場合
    else
      # [常時] または [メニューのみ] なら使用可
      return (occasion == 0 or occasion == 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃の効果適用
  #     attacker : 攻撃者 (バトラー)
  #--------------------------------------------------------------------------
  def xrxs19_attack_effect(attacker)
    # クリティカルフラグをクリア
    self.critical = false
    # 命中計算絡
    hit = (attacker.hp * 20 / attacker.maxhp) + 80
    # 基本ダメージを計算
    if XRXS.element_include?(attacker.element_set, XRXS19::ATTACK) == XRXS.element_include?(attacker.element_set, XRXS19::MAGIC)
      self.damage = (attacker.str ** 1.5 * attacker.int ** 1.5 * attacker.atk ** 2) ** 0.3
    elsif XRXS.element_include?(attacker.element_set, XRXS19::ATTACK)
      self.damage = (attacker.str ** 3.5 * attacker.atk ** 1.5) ** 0.3
    else
      self.damage = (attacker.int ** 3.5 * attacker.atk ** 1.5) ** 0.3
    end
    # 属性修正
    if self.class.method_defined?("multy_element_set")
      self.damage *= elements_correct(attacker.multy_element_set)
    else
      self.damage *= elements_correct(attacker.equip_element_set)
    end
    self.damage /= 100
    # クリティカル修正
    if rand(100) < attacker.dex
      self.critical = true
      self.damage *= 2
    end
    # ダメージの符号が正の場合
    if self.damage > 0
      d = self.damage
      # 防御力修正
      if XRXS.element_include?(attacker.element_set, XRXS19::ATTACK) == XRXS.element_include?(attacker.element_set, XRXS19::MAGIC)
        self.damage = self.damage * 555 / ((self.mdef * self.pdef) ** 0.75 + 554)
      elsif XRXS.element_include?(attacker.element_set, XRXS19::ATTACK)
        self.damage = self.damage * 555 / (self.pdef ** 1.5 + 554)
      else
        self.damage = self.damage * 555 / (self.mdef ** 1.5 + 554)
      end
      # 防御修正
      if self.guarding?
        self.damage /= 2
      end
    end
    # 分散
    if self.damage != 0 and attacker.current_action.add_variance == 0
      seed = rand(XRXS19::ATTACK_VARY * 2 + 1) - XRXS19::ATTACK_VARY
      self.damage += (self.damage * seed / XRXS19::VARY_BASE)
    end
    # 命中判定
    hit = hit * attacker.hit * (100 - self.eva) * (100 + attacker.current_action.hit_plus) / 1000000
    hit = self.cant_evade? ? 100 : hit
    hit_result = (rand(100) < hit)
    # 命中の場合
    if hit_result
      # 小数点以下丸め
      self.damage = self.damage.round
      # ステート衝撃解除
      if self.damage >= 0 and not attacker.current_action.not_shock
        remove_states_shock
      end
      # HP からダメージを減算
      self.hp -= self.damage
      # ステート変化
      @state_changed = false
      if self.class.method_defined?("state_rate")
        states_plus(attacker)
        states_minus(attacker)
      else
        states_plus(attacker.plus_state_set)
        states_minus(attacker.minus_state_set)
      end
    # ミスの場合
    else
      # ダメージに "Miss" を設定
      self.damage = "Miss"
      # クリティカルフラグをクリア
      self.critical = false
    end
    # メソッド終了
    return true
  end
  #--------------------------------------------------------------------------
  # ● スキルの効果適用
  #     user  : スキルの使用者 (バトラー)
  #     skill : スキル
  #--------------------------------------------------------------------------
  def xrxs19_skill_effect(user, skill)
    # クリティカルフラグをクリア
    self.critical = false
    # スキルの効果範囲が HP 1 以上の味方で、自分の HP が 0 の場合
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0)
      # メソッド終了
      return false
    end
    # 有効フラグをクリア
    effective = false
    # コモンイベント ID が有効の場合は有効フラグをセット
    effective |= skill.common_event_id > 0
    # 第一命中判定
    hit_ = (user.hp * 10 / user.maxhp) + 90
    # 不確実なスキルの場合は有効フラグをセット
    effective |= hit < 100
    # 基本ダメージを計算
    if XRXS.element_include?(skill.element_set, XRXS19::ATTACK) == XRXS.element_include?(skill.element_set, XRXS19::MAGIC)
      base = Math.sqrt(Math.sqrt(user.str ** 2 * user.int ** 2 * skill.power.abs ** 2))
    elsif XRXS.element_include?(skill.element_set, XRXS19::ATTACK)
      self.damage = ((user.str ** 3 * user.atk) ** 0.4) * skill.power.abs / 16
    else
      self.damage = (user.int ** 3 * skill.power.abs ** 2 * user.atk) ** 0.25
    end
    if skill.power < 0
      self.damage *= -1
    end
    # 属性修正
    self.damage *= elements_correct(user.skill_element_set(skill))
    self.damage /= 100
    # クリティカル修正
    if rand(100) < skill.dex_f
      self.damage *= 2
      self.critical = true
    end
    # ダメージの符号が正の場合
    if self.damage > 0
      # 防御力修正
      if XRXS.element_include?(skill.element_set, XRXS19::ATTACK) == XRXS.element_include?(skill.element_set, XRXS19::MAGIC)
        self.damage = self.damage * 2098 / (self.mdef * self.pdef + 2097)
      elsif XRXS.element_include?(skill.element_set, XRXS19::ATTACK)
        self.damage = self.damage * 2098 / (self.pdef + 2097)
      else
        self.damage = self.damage * 2098 / (self.mdef + 2097)
      end
      # 防御修正
      if self.guarding?
        self.damage /= 2
      end
    end
    # 分散
    if skill.variance > 0 and self.damage != 0
      seed = rand(skill.variance * 2 + 1) - skill.variance
      self.damage += (self.damage * seed / XRXS19::VARY_BASE)
    end
    # 命中判定
    eva = 100 - self.eva
    hit1 = hit * skill.hit * eva * (100 + user.current_action.hit_plus) / 1000000
    hit2 = self.cant_evade? ? 100 : hit1
    hit_result = (rand(100) < hit2)
    # 不確実なスキルの場合は有効フラグをセット
    effective |= hit < 100
    # 命中の場合
    if hit_result
      # 小数点以下丸め
      self.damage = self.damage.round
      # ダメージ 0 以上の攻撃の場合
      if self.damage > 0 and not user.current_action.not_shock
        # ステート衝撃解除
        remove_states_shock
        # 有効フラグをセット
        effective = true
      end
      # HP からダメージを減算
      last_hp = self.hp
      self.hp -= self.damage
      effective |= self.hp != last_hp
      # ステート変化
      @state_changed = false
      if self.class.method_defined?("state_rate")
        effective |= states_plus(user, skill)
        effective |= states_minus(user, skill)
      else
        effective |= states_plus(skill.plus_state_set)
        effective |= states_minus(skill.minus_state_set)
      end
      # 威力が 0 の場合
      if skill.power == 0
        # ダメージに空文字列を設定
        self.damage = ""
        # ステートに変化がない場合
        unless @state_changed
          # ダメージに "Guard" を設定
          self.damage = "Guard"
        end
      end
    # ミスの場合
    else
      # ダメージに "Miss" を設定
      self.damage = "Miss"
    end
    # 戦闘中でない場合
    unless $game_temp.in_battle
      # ダメージに nil を設定
      self.damage = nil
    end
    # メソッド終了
    return effective
  end
  #--------------------------------------------------------------------------
  # ● アイテムの効果適用
  #     item : アイテム
  #--------------------------------------------------------------------------
  def item_effect(item)
    # クリティカルフラグをクリア
    self.critical = false
    # アイテムの効果範囲が HP 1 以上の味方で、自分の HP が 0の場合
    if ((item.scope == 3 or item.scope == 4) and self.hp == 0)
      # メソッド終了
      return false
    end
    # 有効フラグをクリア
    effective = false
    # コモンイベント ID が有効の場合は有効フラグをセット
    effective |= item.common_event_id > 0
    # 命中判定
    hit_result = (rand(100) < item.hit)
    # 不確実なスキルの場合は有効フラグをセット
    effective |= item.hit < 100
    # 命中の場合
    if hit_result == true
      # 回復量を計算
      recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
      recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
      if recover_hp < 0
        recover_hp += self.pdef * item.pdef_f / 20
        recover_hp += self.mdef * item.mdef_f / 20
      end
      if recover_sp < 0
        recover_sp += self.pdef * item.pdef_f / 20
        recover_sp += self.mdef * item.mdef_f / 20
      end
      # 属性修正
      recover_hp *= elements_correct(item.element_set)
      recover_hp /= 100
      recover_sp *= elements_correct(item.element_set)
      recover_sp /= 100
      # 分散
      if item.variance > 0 and (recover_hp.abs > 0 or recover_sp.abs > 0)
        seed = rand(item.variance * 2 + 1) - item.variance
        recover_hp += (recover_hp * seed / XRXS19::VARY_BASE)
        recover_sp += (recover_sp * seed / XRXS19::VARY_BASE)
      end
      # 防御修正
      if self.guarding?
        # 回復量の符号が負の場合
        if recover_hp < 0
          recover_hp /= 2
        end
        if recover_sp < 0
          recover_sp /= 2
        end
      end
      # 小数点以下丸め
      recover_hp = recover_hp.round
      recover_sp = recover_sp.round
      # HP 回復量の符号を反転し、ダメージの値に設定
      self.damage = -recover_hp
      self.damage_sp = -recover_sp
      # HP および SP を回復
      last_hp = self.hp
      last_sp = self.sp
      self.hp += recover_hp
      self.sp += recover_sp
      effective |= self.hp != last_hp
      effective |= self.sp != last_sp
      # ステート変化
      @state_changed = false
      if self.class.method_defined?("state_rate")
        effective |= states_plus(item)
        effective |= states_minus(item)
      else
        effective |= states_plus(item.plus_state_set)
        effective |= states_minus(item.minus_state_set)
      end
      # パラメータ上昇値が有効の場合
      if item.parameter_type > 0 and item.parameter_points != 0
        # パラメータで分岐
        case item.parameter_type
        when 1  # MaxHP
          @maxhp_plus += item.parameter_points
        when 2  # MaxSP
          @maxsp_plus += item.parameter_points
        when 3  # 腕力
          @str_plus += item.parameter_points
        when 4  # 器用さ
          @dex_plus += item.parameter_points
        when 5  # 素早さ
          @agi_plus += item.parameter_points
        when 6  # 魔力
          @int_plus += item.parameter_points
        end
        # 有効フラグをセット
        effective = true
      end
      # HP 回復率と回復量が 0 の場合
      if item.recover_hp_rate == 0 and item.recover_hp == 0
        # ダメージに空文字列を設定
        self.damage = ""
        # SP 回復率と回復量が 0、パラメータ上昇値が無効の場合
        if item.recover_sp_rate == 0 and item.recover_sp == 0 and
           (item.parameter_type == 0 or item.parameter_points == 0)
          # ステートに変化がない場合
          unless @state_changed
            # ダメージに "Guard" を設定
            self.damage = "Guard"
          end
        end
      end
      # SP変化が0の場合、nilとする
      self.damage_sp = nil if self.damage_sp == 0
    # ミスの場合
    else
      # ダメージに "Miss" を設定
      self.damage = "Miss"
    end
    # 戦闘中でない場合
    unless $game_temp.in_battle
      # ダメージに nil を設定
      self.damage = nil
    end
    # メソッド終了
    return effective
  end
  #--------------------------------------------------------------------------
  # ○ 効果適用
  #--------------------------------------------------------------------------
  def effect_it(user, skill = nil)
    # 特殊効果予約：SPダメージ
    sp_damage_plan = user.current_action.sp_damage
    # 実行前の数値を保持
    last_hp = self.hp
    last_sp = self.sp
    last_states = self.states.dup
    # 特殊効果：必中
    if user.current_action.certain_hit
      self.certain_hit = true
    end
    # 特殊効果：現HP威力
    if skill != nil and XRXS.element_include?(user.skill_element_set(skill), "現HP威力")
      skill = skill.dup
      skill.power = (1.0 * skill.power * user.hp / user.maxhp).floor
    end
    # 特殊効果：減HP威力
    if skill != nil and XRXS.element_include?(user.skill_element_set(skill), "減HP威力")
      skill = skill.dup
      skill.power = (1.0 * skill.power * (user.maxhp - user.hp) / user.maxhp).floor
    end
    # 特殊効果：現SP威力
    if skill != nil and XRXS.element_include?(user.skill_element_set(skill), "現SP威力")
      skill = skill.dup
      skill.power = (1.0 * skill.power * user.sp / user.maxsp).floor
    end
    # 特殊効果：減SP威力
    if skill != nil and XRXS.element_include?(user.skill_element_set(skill), "減SP威力")
      skill = skill.dup
      skill.power = (1.0 * skill.power * (user.maxsp - user.sp) / user.maxsp).floor
    end
    #/---
    # 基本実行、skill が nil かどうかで通常攻撃とスキルを分別
    save_in_battle = $game_temp.in_battle
    $game_temp.in_battle = true
    last_immortal = @immortal
    @immortal = !(self.dead?)
    if skill == nil
      bool = xrxs19_attack_effect(user)
    else
      bool = xrxs19_skill_effect(user, skill)
    end
    #
    # --- ダメージを測定 -------------------------------------------------
    #
    self.damage = 0 if self.damage == "Guard"
    damage    = self.damage
    damage_sp = 0
    defeated  = self.dead?
    @immortal = last_immortal
    $game_temp.in_battle = save_in_battle
    #---/
    
    # HP回復スキルの判定
    if skill != nil and skill.power < 0 and !user.current_action.sp_damage
      # 既に最大HPかつステート不変かどうかで有効フラグをセット
      bool = false if (last_hp == self.maxhp and last_states == self.states)
    elsif user.current_action.sp_damage
      # SPダメージの場合は一旦trueへ (Thx. Tetra-Z)
      bool = true
    end
    # 必中の解除
    self.certain_hit = false
    # 基本実行でfalseの場合ここで終了する ("銭投げ"は確実成功)
    if !bool or !self.damage.is_a?(Numeric)
      return bool
    end
    #
    # --- ダメージを変化させる -------------------------------------------
    #
    if self.class.method_defined?("multy_element_set")
      eleset = user.multy_element_set
    else
      eleset = user.equip_element_set
    end
    # 特殊効果：現HP威力
    if skill.nil? and XRXS.element_include?(eleset, "現HP威力")
      damage = (1.0 * damage * user.hp / user.maxhp).floor
    end
    # 特殊効果：減HP威力
    if skill.nil? and XRXS.element_include?(eleset, "減HP威力")
      damage = (1.0 * damage * (user.maxhp - user.hp) / user.maxhp).floor
    end
    # 特殊効果：現SP威力
    if skill.nil? and XRXS.element_include?(eleset, "現SP威力")
      damage = (1.0 * damage * user.sp / user.maxsp).floor
    end
    # 特殊効果：減SP威力
    if skill.nil? and XRXS.element_include?(eleset, "減SP威力")
      damage = (1.0 * damage * (user.maxsp - user.sp) / user.maxsp).floor
    end
    # 特殊効果：防御能力の判定
    if damage > 0 and self.guarding? and not user.current_action.guard_break
      if Numset.const_defined?("GUARD_BASE")
        damage = damage * 100 / Numset::GUARD_BASE
        case battler_element_rank?(self, "防御能力")
        when 1 # 特殊効果：防御能力 A（無効防御）
          damage = 0
        when 2 # 特殊効果：防御能力 B（強防御）
          damage = damage * (Numset::GUARD_BASE ** 2) / 10000
        when 4 # 特殊効果：防御能力 D（(100-防御効果)%の確率で無効）
          damage = 0 if rand(100) <= Numset::GUARD_BASE
        when 5 # 特殊効果：防御能力 E（SP防御）
          if XRXS19::SP_GUARD_COST != 0
            sp_cost = XRXS19::SP_GUARD_COST
          else
            sp_cost = damage
          end
          if self.sp >= sp_cost
            damage = XRXS19::SP_GUARD_COST if XRXS19::SP_GUARD_COST != 0
            sp_damage_plan = true
          end
        when 6 # 特殊効果：防御能力 F（防御効果反転）
          damage = damage * 100 / Numset::GUARD_BASE
        end
      else
        damage *= 2
        case battler_element_rank?(self, "防御能力")
        when 1 # 特殊効果：防御能力 A（無効防御）
          damage = 0
        when 2 # 特殊効果：防御能力 B（倍防御）
          damage /= 4
        when 4 # 特殊効果：防御能力 D（50%の確率で無効）
          damage = 0 if rand(100) <= 50
        when 5 # 特殊効果：防御能力 E（SP防御）
          if XRXS19::SP_GUARD_COST != 0
            sp_cost = XRXS19::SP_GUARD_COST
          else
            sp_cost = damage
          end
          if self.sp >= sp_cost
            damage = XRXS19::SP_GUARD_COST if XRXS19::SP_GUARD_COST != 0
            sp_damage_plan = true
          end
        when 6 # 特殊効果：防御能力 F（ダメージ２倍）
          damage *= 2
        end
      end
    end
    # 特殊効果：必殺
    if user.current_action.critical_hit[0] != 0 or user.current_action.critical_hit[1] != 0
      # クリティカルが発生していた場合、それを取りやめる
      if self.critical
        if Numset.const_defined?("CRITICAL_BASE")
          damage = damage * 100 / Numset::CRITICAL_BASE
        else
          damage /= 2
        end
      end
      # クリティカル判定
      if Numset.const_defined?("DAMAGE_DEFINE")
        base = critical_base(user, skill)
      else
        if skill == nil
          base = user.dex
        else
          base = skill.dex_f
        end
      end
      base = base * user.current_action.critical_hit[0] / 100
      base += user.current_action.critical_hit[1]
      if rand(100) < base
        if Numset.const_defined?("CRITICAL_BASE")
          damage = damage * Numset::CRITICAL_BASE / 100
        else
          damage *= 2
        end
      # デメリットが有効な場合
      elsif XRXS19::DE_MERIT
        damage = damage * 2 / 3
      end
    end
    # 特殊効果：必殺強化
    if user.current_action.critical_plus > 0
      # クリティカルが発生していた場合、倍率補正をやめる
      if self.critical
        if Numset.const_defined?("CRITICAL_BASE")
          damage = damage * 100 / Numset::CRITICAL_BASE
        else
          damage /= 2
        end
        # 倍率補正
        damage = damage * user.current_action.critical_plus / 100
      end
    end
    if skill != nil
      offence = user.skill_element_set(skill)
      if self.class.method_defined?("multy_element_set")
        defence = self.multy_element_set
      else
        defence = self.equip_element_set
      end
      check = skill.element_set
    elsif self.class.method_defined?("multy_element_set")
      offence = user.multy_element_set
      defence = self.multy_element_set
      check = user.element_set
    else
      offence = user.equip_element_set
      defence = self.equip_element_set
      check = user.element_set
    end
    attack_text = (Numset.const_defined?("ATTACK") ? Numset::ATTACK : XRXS19::ATTACK)
    magic_text = (Numset.const_defined?("MAGIC") ? Numset::MAGIC : XRXS19::MAGIC)
    plus_set = 0
    for i in offence
      if XRXS.element_include?(check, attack_text) and $data_system.elements[i] =~ /^#{attack_text}攻撃([+-]?([1-9]\d*|0)\.?\d*)?([%％])?$/
        if $3 != nil
          damage = damage * (100 + $1.to_i) / 100
        else
          plus_set += $1.to_i
        end
      end
      if XRXS.element_include?(check, magic_text) and $data_system.elements[i] =~ /^#{magic_text}攻撃([+-]?([1-9]\d*|0)\.?\d*)?([%％])?$/
        if $3 != nil
          damage = damage * (100 + $1.to_i) / 100
        else
          plus_set += $1.to_i
        end
      end
    end
    for i in defence
      if XRXS.element_include?(check, attack_text) and $data_system.elements[i] =~ /^#{attack_text}防御([+-]?([1-9]\d*|0)\.?\d*)?([%％])?$/
        if $3 != nil
          damage = damage * (100 - $1.to_i) / 100
        else
          plus_set -= $1.to_i
        end
      end
      if XRXS.element_include?(check, magic_text) and $data_system.elements[i] =~ /^#{magic_text}防御([+-]?([1-9]\d*|0)\.?\d*)?([%％])?$/
        if $3 != nil
          damage = damage * (100 - $1.to_i) / 100
        else
          plus_set -= $1.to_i
        end
      end
    end
    # 絶対指定は最後に追加
    self.damage += plus_set
    # HPの吸収量があり、かつデメリットが有効な場合
    if user.current_action.hp_drain > 0 and XRXS19::DE_MERIT
      damage /= 1.5
    end
    # SPの吸収量があり、かつデメリットが有効な場合
    if user.current_action.sp_drain > 0 and XRXS19::DE_MERIT
      damage /= 1.5
    end
    # 特殊効果：固定ダメージ ( 固定ダメージ故クリティカルを禁止 )
    case user.current_action.special_damage_kind
    when XRXS19::NOWHPP # 「％ダメージ」
      if skill == nil
        damage = last_hp / 2 + 1
      else
        damage = last_hp * skill.power / 100
      end
      self.critical = false
    when XRXS19::MAXHPP # 「最大％ダメージ」
      if skill == nil
        damage = self.maxhp / 4 + 1
      else
        damage = self.maxhp * skill.power / 100
      end
      self.critical = false
    when XRXS19::USERHP # 「現在HPダメージ」
      damage = user.hp
      self.critical = false
    when XRXS19::DIFFHP # 「差分HPダメージ」
      damage = user.maxhp - user.hp
      self.critical = false
    end
    # 特殊効果「分散度」
    if user.current_action.add_variance != 0
      variance = user.current_action.add_variance
      if variance > 0 and damage.abs > 0
        seed = rand(skill.variance * 2 + 1) - skill.variance
        if Numset.const_defined?("VARY_BASE")
          self.damage += (self.damage * seed / Numset::VARY_BASE)
        else
          self.damage += (self.damage * seed / XRXS19::VARY_BASE)
        end
      end
    end
    # 特殊効果「固定ダメージ」
    if user.current_action.fix_damage != 0
      damage = user.current_action.fix_damage
    end
    # 特殊効果：CPダメージ
    if user.current_action.cp_damage > 0
      if defined? self.cp
        # 今回のダメージの、最大HPに対する割合を計算
        damage_cp = user.current_action.cp_damage * self.max_cp * damage / self.maxhp / 100
        self.cp  -= damage_cp
        damage = damage * (100 - user.current_action.cp_damage) / 100
        self.damage = damage == 0 ? nil : damage
      end
    end
    # 特殊効果：SPダメージ
    if sp_damage_plan > 0
      damage_sp = damage * sp_damage_plan / 100
      unless user.current_action.hpsp_damage
        damage = 0
        self.damage = nil
      end
      #
      # メモ :(RGSS標準) .damageがnilの場合、ステートの変化が即座に表示される。
      #
      # SP回復スキルの判定
      if skill != nil and skill.power < 0
        # 既に最大SPかつステート不変かどうかで有効フラグをセット (Thx. Tetra-Z)
        bool = false if (last_sp == self.maxsp and last_states == self.states)
      end
    end
    # ダメージ上限設定
    if damage >= XRXS19::DAMAGE_LIMIT
      damage = XRXS19::DAMAGE_LIMIT
    elsif damage <= -XRXS19::DAMAGE_LIMIT
      damage = -XRXS19::DAMAGE_LIMIT
    end
    # んでまた丸める
    damage = damage.round
    #
    # --- ダメージを適用する ---------------------------------------------
    #
    self.hp        = last_hp - damage
    self.damage    = damage if self.damage.is_a?(Numeric)
    self.sp        = last_sp - damage_sp if damage_sp != 0
    self.damage_sp = damage_sp == 0 ? nil : damage_sp
    self.hp        = 0 if defeated
    #
    # 特殊効果「HP吸収」「SP吸収」
    #
    if user.current_action.hp_drain > 0
      user.damage  = 0 if user.damage == nil # nil の場合はリセット
      drain_point  = -[damage, last_hp].min * user.current_action.hp_drain / 100
      user.damage += drain_point
      user.hp     -= drain_point
      if user.damage == 0
        user.damage  = nil
      end
    elsif user.current_action.sp_drain > 0
      user.damage_sp  = 0 if user.damage_sp == nil # nil の場合はリセット
      drain_point     = -[damage_sp, last_sp].min * user.current_action.sp_drain / 100
      user.damage_sp += drain_point
      user.sp        -= drain_point
      if user.damage_sp == 0
        user.damage_sp  = nil
      end
    end
    # 数字を使う故に、ここに移動
    if self.damage == 0
      self.damage = "Guard"
    end
    # 終了
    return bool
  end
end