=begin
 提供してくださった皆様
 Kai様
 フィアルー(現Zyx)様
 ヘンリー様
=end

#==============================================================================
# ■ Numset
#------------------------------------------------------------------------------
# 定数を設定するモジュールです。
#==============================================================================

module Numset
  DAMAGE_DEFINE = "ダメージ定義"          # タイプを指定。
  ATTACK = "攻撃"                         # 攻撃属性
  MAGIC = "魔法"                          # 魔法属性
  ATTACK_SEAL = "物理封じ"                # 物理封じ続性
  MAGIC_SEAL = "魔法封じ"                 # 魔法封じ続性
  CRITICAL_GUARD = "クリティカル"         # クリティカル防御属性
  ATTACK_MODE = 1                         # 通常攻撃のタイプ
  SKILL_MODE = 1                          # スキルのタイプ
  ITEM_MODE = 1                           # アイテムのタイプ
  VARY_BASE = 256                         # 乱数の基本単位(分の1)
  ATTACK_VARY = 16                        # 通常攻撃の乱数基本値
  CRITICAL_BASE = 200                     # クリティカル倍率(%)
  GUARD_BASE = 50                         # 防御倍率(%)
end
module Math
  class << self
    alias :base_sqrt :sqrt
    def sqrt(x)
      return base_sqrt(x.abs)
    end
  end
end

#==============================================================================
# ■ Game_Battler
#------------------------------------------------------------------------------
# 　バトラーを扱うクラスです。このクラスは Game_Actor クラスと Game_Enemy クラ
# スのスーパークラスとして使用されます。
#==============================================================================

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, Numset::ATTACK)
        @states.each{|state| i = state.guard_element_set
        if XRXS.element_include?(i, Numset::ATTACK_SEAL)
          return false
        end
        }
      # 魔法封じ状態の場合、魔法スキルは使用不可
      elsif XRXS.element_include?(skill.element_set, Numset::MAGIC)
        @states.each{|state| i = state.guard_element_set
        if XRXS.element_include?(i, Numset::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 attack_effect(attacker)
    # 属性から攻撃タイプを設定
    damage_type = XRXS.element_amount(attacker.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    if damage_type == 0
      damage_type = Numset::ATTACK_MODE
    end
    # クリティカルフラグをクリア
    self.critical = false
    case damage_type
    when 1
      # 基本ダメージを計算
      if XRXS.element_include?(attacker.element_set, Numset::ATTACK) == XRXS.element_include?(attacker.element_set, Numset::MAGIC)
        self.damage = (attacker.str ** 1.5 * attacker.int ** 1.5 * attacker.atk ** 2) ** 0.3
      elsif XRXS.element_include?(attacker.element_set, Numset::ATTACK)
        self.damage = (attacker.str ** 3 * attacker.atk ** 2) ** 0.3
      else
        self.damage = (attacker.int ** 4 * attacker.atk) ** 0.3
      end
      # 属性修正
      self.damage *= elements_correct(attacker.multy_element_set)
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(attacker)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.critical = true
        self.damage = self.damage * Numset::CRITICAL_BASE / 100
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御力補正
        if XRXS.element_include?(attacker.element_set, Numset::ATTACK) == XRXS.element_include?(attacker.element_set, Numset::MAGIC)
          self.damage = self.damage * 2098 / (self.pdef * self.mdef + 2097)
        elsif XRXS.element_include?(attacker.element_set, Numset::ATTACK)
          self.damage = self.damage * 2098 / (self.pdef ** 2 + 2097)
        else
          self.damage = self.damage * 2098 / (self.mdef ** 2 + 2097)
        end
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if self.damage != 0 and attacker.current_action.add_variance == 0
        seed = rand(Numset::ATTACK_VARY * 2 + 1) - Numset::ATTACK_VARY
        self.damage += (self.damage * seed / Numset::VARY_BASE)
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(attacker))
    when 2
      # 基本ダメージを計算
      atk = [attacker.atk + attacker.str - self.pdef, 0].max
      # 属性修正
      self.damage *= elements_correct(attacker.multy_element_set)
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(attacker)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.damage = (self.damage * Numset::CRITICAL_BASE / 100)
        self.critical = true
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if self.damage.abs > 0
        amp = [self.damage.abs * Numset::ATTACK_VARY / Numset::VARY_BASE, 1].max
        self.damage += rand(amp + 1) + rand(amp + 1) - amp
      end
      # 命中判定
      eva = self.agi - attacker.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 + attacker.hit - 125 - eva
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
    when 3
      # 基本ダメージを計算
      self.damage = attacker.atk * attacker.str / (self.pdef + self.str + 1)
      # 属性修正
      self.damage *= elements_correct(attacker.multy_element_set)
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(attacker)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.critical = true
        self.damage = self.damage * Numset::CRITICAL_BASE / 100
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if self.damage.abs > 0
        amp = [self.damage.abs * Numset::ATTACK_VARY / Numset::VARY_BASE, 1].max
        self.damage += rand(amp + 1) + rand(amp + 1) - amp
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(attacker))
    end
    # 命中の場合
    if hit_result
      # ダメージを丸める
      self.damage = self.damage.round
      # ステート衝撃解除
      if self.damage > 0
        unless Game_BattleAction.method_defined?("not_shock") or not attacker.current_action.not_shock
          remove_states_shock
        end
      end
      # HP からダメージを減算
      self.hp -= self.damage
      # ステート変化
      @state_changed = false
      if self.class.method_defined?("state_rate")
        states_plus(attacker.multy_element_set)
        states_minus(attacker.multy_element_set)
      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
  # 追加判定を行う
  if self.class.method_defined?("effect_it")
    alias :xrxs19_attack_effect :attack_effect
    def attack_effect(attacker)
      return effect_it(attacker)
    end
  end
  #--------------------------------------------------------------------------
  # ● スキルの効果適用
  #     user  : スキルの使用者 (バトラー)
  #     skill : スキル
  #--------------------------------------------------------------------------
  def skill_effect(user, skill)
    # 属性から攻撃タイプを設定
    damage_type = XRXS.element_amount(skill.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    if damage_type == 0
      damage_type = Numset::SKILL_MODE
    end
    #クリティカルフラグをクリア
    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
    case damage_type
    when 1
      # 不確実なスキルの場合は有効フラグをセット
      effective |= hit < 100
      # 基本ダメージを計算
      if XRXS.element_include?(user.skill_element_set(skill), XRXS19::ATTACK) == XRXS.element_include?(user.skill_element_set(skill), XRXS19::MAGIC)
        base = Math.sqrt(user.str ** 2 * user.int ** 2 * skill.power.abs ** 3)
      elsif XRXS.element_include?(user.skill_element_set(skill), XRXS19::ATTACK)
        base = Math.sqrt(user.str ** 2 * skill.power.abs ** 3) * user.atk
      else
        base = Math.sqrt(user.int ** 2 * skill.power.abs ** 3) * user.int
      end
      self.damage = Math.sqrt(base) * 2
      self.damage *= -1 if skill.power < 0
      # 属性修正
      self.damage *= elements_correct(user.skill_element_set(skill))
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(user, skill)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.damage = self.damage * Numset::CRITICAL_BASE / 100
        self.critical = true
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御力修正
        if XRXS.element_include?(user.skill_element_set(skill), XRXS19::ATTACK) == XRXS.element_include?(user.skill_element_set(skill), XRXS19::MAGIC)
          self.damage = self.damage * 2098 / (Math.sqrt(self.mdef * self.pdef + 2097))
        elsif XRXS.element_include?(user.skill_element_set(skill), XRXS19::ATTACK)
          self.damage = self.damage * 2098 / (self.pdef ** 2 + 2097)
        else
          self.damage = self.damage * 2098 / (self.mdef ** 2 + 2097)
        end
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if skill.variance > 0 and self.damage != 0
        seed = rand(skill.variance * 2 + 1) - skill.variance
        self.damage += (self.damage * seed / Numset::VARY_BASE)
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(user, skill))
    when 2
      # 威力を計算
      power = user.atk * skill.atk_f / 100
      bougyo = self.pdef * skill.pdef_f / 100 + self.mdef * skill.mdef_f / 100
      # 倍率を計算
      rate = 0
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
      self.damage = (1.0 * (power + rate) * skill.power / 100.0).round - bougyo
      # 属性修正
      self.damage *= elements_correct(user.skill_element_set(skill))
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(user, skill)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.damage = (self.damage * Numset::CRITICAL_BASE / 100)
        self.critical = true
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / Numset::VARY_BASE, 1].max
        self.damage += rand(amp + 1) + rand(amp + 1) - amp
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(user, skill))
    when 3
      # 不確実なスキルの場合は有効フラグをセット
      effective |= hit < 100
      # 威力を計算
      power = skill.power + user.atk
      rate = user.str * skill.str_f / 20 + user.dex * skill.dex_f / 20 + user.agi * skill.agi_f / 20 + user.int * skill.int_f / 20
      guard = (self.pdef + self.str) * self.pdef_f / 20 + (self.mdef + self.int) * self.mdef_f / 20 + 1
      # 基本ダメージを計算
      self.damage = power * rate / guard
      # 属性修正
      self.damage *= elements_correct(user.skill_element_set(skill))
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(user, skill)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.damage = self.damage * Numset::CRITICAL_BASE / 100
        self.critical = true
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / Numset::VARY_BASE, 1].max
        self.damage += (rand(amp + 1) + rand(amp + 1) - amp)
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(user, skill))
    when 4
      # F計算
      skill_f = skill.str_f + skill.dex_f + skill.agi_f + skill.int_f
      guard_f = skill.pdef_f + skill.mdef_f
      if guard_f != 0
        pdef_f = skill.pdef_f * 100 / guard_f
        mdef_f = skill.mdef_f * 100 / guard_f
      else
        pdef_f = 0
        mdef_f = 0
      end
      if skill_f != 0
        str_f = skill.str_f * 100 / skill_f
        dex_f = skill.dex_f * 100 / skill_f
        agi_f = skill.agi_f * 100 / skill_f
        int_f = skill.int_f * 100 / skill_f
      else
        str_f = 0
        dex_f = 0
        agi_f = 0
        int_f = 0
      end
      # 命中計算
      hit = skill.hit * user.hit / 100
      # 不確実なスキルの場合は有効フラグをセット
      effective |= hit < 100
      # 威力を計算
      power = user.atk
      power -= self.pdef * pdef_f / 200
      power -= self.mdef * mdef_f / 200
      power = [power, 0].max
      power = power * skill.power / 100
      # 倍率を計算
      rate = 20
      rate += (user.str * str_f / 100)
      rate += (user.dex * dex_f / 100)
      rate += (user.agi * agi_f / 100)
      rate += (user.int * int_f / 100)
      # 基本ダメージを計算
      self.damage = power * rate / 20
      # 属性修正
      self.damage *= elements_correct(user.skill_element_set(skill))
      self.damage /= 100
      # クリティカル修正
      c_base = critical_base(user, skill)
      amount = XRXS.element_amount(self.multy_element_set, Numset::CRITICAL_GUARD)
      percent = XRXS.element_percent(self.multy_element_set, Numset::CRITICAL_GUARD)
      c_base = c_base * (100 - percent) / 100 - amount
      if rand(100) < c_base
        self.damage = self.damage * Numset::CRITICAL_BASE / 100
        self.critical = true
      end
      # ダメージの符号が正の場合
      if self.damage > 0
        # 防御修正
        if self.guarding?
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
        # 防御力修正
        mdef_plus = 25 * int_f * user.int / self.int / 100
        if rand(100) < mdef_plus
          self.damage = self.damage * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / Numset::VARY_BASE, 1].max
        self.damage += rand(amp + 1) + rand(amp + 1) - amp
      end
      # 命中判定
      hit_result = (rand(100) < hit_base(user, skill))
    end
    # 不確実なスキルの場合は有効フラグをセット
    effective |= hit < 100
    # 命中の場合
    if hit_result
      # 小数点以下丸め
      self.damage = self.damage.round
      # ダメージ 0 以上の攻撃の場合
      if self.damage > 0
        unless Game_BattleAction.method_defined?("not_shock") or not user.curllent_action.not_shock
          # ステート衝撃解除
          remove_states_shock
          # 有効フラグをセット
          effective = true
        end
      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_element_set(skill))
        effective |= states_minus(user.skill_element_set(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
  # 強引に併用化
  if self.class.method_defined?("effect_it")
    alias :xrxs19_skill_effect :skill_effect
    def skill_effect(user, skill)
      return effect_it(user, skill)
    end
  end
  #--------------------------------------------------------------------------
  # ● アイテムの効果適用
  #     item : アイテム
  #--------------------------------------------------------------------------
  def item_effect(item)
    # 属性から攻撃タイプを設定
    damage_type = XRXS.element_amount(skill.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    if damage_type == 0
      damage_type = Numset::ITEM_MODE
    end
    # クリティカルフラグをクリア
    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
    case damage_type
    when 1
      # 命中判定
      hit_result = (rand(100) < item.hit)
      # 不確実なスキルの場合は有効フラグをセット
      effective |= item.hit < 100
      # 回復量を計算
      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
        recover_hp = [recover_hp, 0].min
      end
      # 属性修正
      recover_hp *= elements_correct(item.element_set)
      recover_hp /= 100
      recover_sp *= elements_correct(item.element_set)
      recover_sp /= 100
      # 防御力修正
      if rand(100) < item.pdef_f
        recover_hp = recover_hp * Numset::CRITICAL_BASE / 100
        recover_sp = recover_sp * Numset::CRITICAL_BASE / 100
        self.critical = true
      end
      # 防御修正
      if self.guarding?
        # 回復量の符号が負の場合
        if recover_hp < 0
          recover_hp = recover_hp * Numset::GUARD_BASE / 100
        end
        if recover_sp < 0
          recover_sp = recover_sp * Numset::GUARD_BASE / 100
        end
      end
      # 分散
      seed = rand(item.variance * 2 + 1) - item.variance
      if item.variance > 0 and recover_hp.abs > 0
        recover_hp += (recover_hp * seed / Numset::VARY_BASE)
      end
      if item.variance > 0 and recover_sp.abs > 0
        recover_sp += (recover_sp * seed / Numset::VARY_BASE)
      end
    end
    # 命中の場合
    if hit_result    self.damage = -recover_hp
      # 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 hit_base(user, skill = nil)
    # 属性によって分岐
    if skill == nil
      damage_type = XRXS.element_amount(user.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    else
      damage_type = XRXS.element_amount(skill.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    end
    if damage_type == 0
      damage_type = Numset::ATTACK_MODE
    end
    case damage_type
    when 1
      if skill == nil
        hit = (attacker.hp * 20 / attacker.maxhp) + 80
        return (self.cant_evade? ? 100 : (hit * attacker.hit * (100 - self.eva) / 10000))
      else
        hit = (attacker.hp * 10 / attacker.maxhp) + 90
        return (self.cant_evade? ? 100 : (hit * skill.hit * (100 - self.eva) / 10000))
      end
    when 2
      if skill == nil
        hit = attacker.hit - 25 + attacker.dex - self.agi
      else
        hit = skill.hit - 25
      end
      return (self.cant_evade? ? 100 : (hit * (100 - self.eva) * skill.eva_f / 10000))
    when 3
      if skill == nil
        eva = 8 * self.agi / attacker.dex + self.eva
        hit = self.damage < 0 ? attacker.hit : attacker.hit * (100 - eva) / 100
      else
        if skill.atk_f > 0
          hit = skill.hit * user.hit / 100
        else
          hit = skill.hit
        end
        eva = 8 * self.agi / user.dex + self.eva
        hit = self.damage < 0 ? hit : hit * (100 - eva) * skill.eva_f / 10000
      end
      return (self.cant_evade? ? 100 : hit)
    when 4
      hit = skill.hit * user.hit / 100
      eva = 8 * self.agi / user.dex + self.eva
      hit = self.damage < 0 ? hit : hit * (100 - eva) * skill.eva_f / 10000
      return (self.cant_evade? ? 100 : hit)
    end
  end
  #--------------------------------------------------------------------------
  # ● クリティカル率の取得
  #--------------------------------------------------------------------------
  def critical_base(user, skill = nil)
    # 属性によって分岐
    if skill == nil
      damage_type = XRXS.element_amount(user.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    else
      damage_type = XRXS.element_amount(skill.element_set, /^#{Numset::DAMAGE_DEFINE}/)
    end
    if damage_type == 0
      damage_type = Numset::ATTACK_MODE
    end
    case damage_type
    when 1
      if skill == nil
        return user.dex
      else
        return skill.dex_f
      end
    when 2
      if Game_Battler.method_defined?("luk") and (attacker.luk - self.luk) > 0
        a = [(attacker.luk - self.luk), 1].max
      else
        a = 1
      end
      b = [(attacker.dex - self.agi), 1].max
      return (a * b / 5.0 + 5)
    when 3
      return (4 * attacker.dex / self.agi)
    when 4
      return (4 * attacker.dex / self.agi)
    end
  end
end