#encoding:utf-8
#===========================================================================
#          RMVA 豪華型技能加點|技能被動效果：        v1.05
#                       By希憶 66rpg.com
#                                                 轉載或修改請保留此類信息
#===========================================================================
# 在遊戲系統類的實現
#
# 完工了，大概
#===========================================================================
#角色類，新增一堆方法。
class Game_Actor < Game_Battler

  #初始化角色
  #@skill_level:存放技能等級數據的哈希表，技能id=>技能等級
  #@sp:剩餘技能點
  alias setup_201410131453 setup
  def setup(actor_id)
    @skill_level=Hash.new(0)
    setup_201410131453(actor_id)
    @sp = (@level-1) * SkillLevel::LEVELUPSP + SkillLevel::INITIALSP
    auto_skill_levelup if self.class.auto_sp
  end

  #讀取技能點的方法，如果是自動升級技能的職業，則沒必要有技能點
  def sp
    return 0 if self.class.auto_sp
    @sp
  end

  #讀取技能基礎等級，
  #鎖定技能等級優先度最高，
  #鏈接技能等級次之，這個我好像在計算技能最終等級的方法裡面又來了一遍。
  #主要是技能基礎等級是升級技能的窗口看到的等級，最終等級是使用技能的窗口。
  def skill_basic_level(skill_id)
    return 0 if skill_id == 0
    lock = $data_skills[skill_id].lock_level
    return lock if lock != 0
    lnk = $data_skills[skill_id].link_skill
    return skill_basic_level(lnk) if lnk != 0
    @skill_level[skill_id]
  end

  #獲取裝備增加技能的等級之和
  def skill_plus_level(skill_id)
    self.equips.compact.inject(0){|skl,eqp| skl+eqp.add_skill(skill_id)}
  end

  #讀取技能最終等級，如果技能基礎等級為零，則不加裝備提升直接等於零。
  #最後返回基礎等級+裝備附加與技能最大等級中的小值
  def skill_level(skill_id)
    return 0 if skill_id == 0
    lock = $data_skills[skill_id].lock_level
    return lock if lock != 0
    lnk = $data_skills[skill_id].link_skill
    return skill_level(lnk) if lnk != 0
    return 0 unless @skills.include?(skill_id)
    return 0 if skill_basic_level(skill_id) == 0
    [skill_basic_level(skill_id) + skill_plus_level(skill_id) ,\
    $data_skills[skill_id].max_level].min
  end

  #升一級技能技能能升級就升級，返回成功，否則返回失敗
  def level_up_skill(skill_id)
    skl = $data_skills[skill_id]
    if skill_can_levelup?(skl)
      @sp -= skl.sp_cost
      @skill_level[skill_id] += 1
      return true
    else
      return false
    end
  end

  #初始化角色時初始化技能的方法，
  #這裡是不管默認的技能設定直接加載能學到的所有技能，也就是職業列表下的那些。
  def init_skills
    @skills = []
    self.class.learnings.each do |learning|
      @skills.push(learning.skill_id)
    end
    @skills.sort!
  end

  #主要用在技能列表的窗口裡的。確保只有技能等級為1級及以上的技能才能顯示。
  def has_skill?(skill)
    skills.include?(skill) && skill_basic_level(skill.id) > 0
  end

  #判斷是否學習了技能，同樣要確保只有技能等級為1級及以上的技能才能顯示。
  #和上面的區別是上面的可以有裝備附帶，狀態附帶的技能等級不為0的技能
  #這裡只能是職業列表下“領悟”的技能，裝備狀態附帶的都不算
  def skill_learn?(skill)
    skill.is_a?(RPG::Skill) && @skills.include?(skill.id) && skill_basic_level(skill.id) > 0
  end

  #判斷前置技能是否都滿足
  def skill_former_match?(skill)
    skill.former.each do |former|
      return false unless skill_basic_level(former[0]) >= former[1]
    end
    true
  end

  #判斷技能是否已經學到精通了
  def skill_max_learn?(skill)
    skill_basic_level(skill.id) == skill.max_learn
  end

  #計算學習下一等級的技能所需要的人物等級
  #如果精通了return false【感覺好像有點奇葩。。。】
  def skill_next_level(skill)
    return false if skill_max_learn?(skill)
    skill.learn_level[0] + skill_basic_level(skill.id) * skill.learn_level[1]
  end

  #技能能否升級？首先看是否鎖定，是否鏈接，是否精通，
  #再看等級是否符合學習下一級，sp是否足夠，前置技能是否滿足要求。
  def skill_can_levelup?(skill)
    return false if skill.lock_level != 0
    return false if skill.link_skill != 0
    return false if skill_max_learn?(skill)
    @level >= skill_next_level(skill) && @sp >= skill.sp_cost && skill_former_match?(skill)
  end

  #好像沒什麼用處。。。當初修改的用意是直接設置技能等級，後來覺得不好控制。。。
  #反正就放著吧，不去管它好了
  def learn_skill(skill_id,sk_level=1)
    unless skill_learn?($data_skills[skill_id])
      @skills.push(skill_id)
      @skills.sort!
      @skill_level[skill_id]=sk_level unless @skill_level.has_key?(skill_id)
    end
  end

  #自動升級技能。
  def auto_skill_levelup
    @skills.each do |skill|
      skl=$data_skills[skill]
      if self.class.auto_sp
        while skill_next_level(skl) && skill_next_level(skl) <= @level do
          @skill_level[skill] += 1
        end
      elsif skl.auto_levelup
        while level_up_skill(skill) do
        end
      end
    end
  end

  #升級時發生的事情，等級+1，sp增加，如果是自動升級技能的職業則自動升級技能
  def level_up
    @level += 1
    @sp += SkillLevel::LEVELUPSP
    auto_skill_levelup
  end

  #被動技能提升的基礎屬性（加法疊加的部分）
  #SkillLevel.formula：帶入公式計算。
  def skill_plus(param_id)
    skills.inject(0) do |plu,skl|
      plu + SkillLevel.formula(self.skill_level(skl.id),skl.param_add(param_id))
    end
  end

  #被動技能提升的基礎屬性倍率（乘法疊加）
  def skill_rate(param_id)
    skills.inject(1.00) do |plu,skl|
      plu * SkillLevel.formula(self.skill_level(skl.id),skl.param_rate(param_id))
    end
  end

  #被動技能影響的屬性抗性（乘法疊加）
  def skill_element_rate(element_id)
    skills.inject(1.00) do |plu,skl|
      plu * SkillLevel.formula(self.skill_level(skl.id),skl.element_rate(element_id))
    end
  end

  #狀態提升的基礎屬性（加法疊加的部分）
  def state_param_plus(param_id)
    states.inject(0) do |plu,sta|
      plu + SkillLevel.formula(@state_level[sta.id],sta.param_add(param_id))
    end
  end
  #狀態提升的基礎屬性倍率（乘法疊加）
  def state_param_rate(param_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.param_rate(param_id))
    end
  end
  #狀態額外影響的屬性抗性（乘法疊加）
  def state_element_rate(element_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.element_rate(element_id))
    end
  end

  #狀態影響的附加屬性xparam
  def state_xparam(xparam_id)
    states.inject(0.0) do |plu,sta|
      plu + SkillLevel.formula(@state_level[sta.id],sta.xparam(xparam_id))
    end
  end


  #狀態影響特殊屬性sparam的計算
  def state_sparam(sparam_id)
    states.inject(1.0) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.sparam(sparam_id))
    end
  end
  #特殊屬性sparam的計算，經驗值比率什麼的，迭代連乘計算。
  def sparam(sparam_id)
    state_sparam(sparam_id)*skills.inject(super(sparam_id)) do |plu,skl|
      plu * SkillLevel.formula(self.skill_level(skl.id),skl.sparam(sparam_id))
    end
  end

  #技能消耗mp由於技能等級修正的倍率，
  #反正就是到SkillLevel.formula找對應編號的公式。
  def skill_mp_rate(skill)
    SkillLevel.formula(skill_level(skill.id),skill.mp_type)
  end

  #計算最終技能消耗mp的量
  def skill_mp_cost(skill)
    (skill.mp_cost * mcr * skill_mp_rate(skill)).to_i
  end

  #計算暴擊傷害倍率super：Game_Battler中的critical_rate，返回1.5
  #人物提升，職業提升，被動技能修正和裝備提升
  def critical_rate
    v = super
    v *= (1.0 + self.actor.critical_rate/100.0)
    v *= (1.0 + self.class.critical_rate/100.0)
    v *= skills.inject(1.00) do |plu,skl|
      plu * SkillLevel.formula(self.skill_level(skl.id),skl.critical_rate)
    end
    v*equips.compact.inject(1.00){ |rat,equip| rat*(1.00+equip.critical_rate/100.0) }
  end

  #屬性傷害修正。
  def element_rate(element_id)
    super(element_id) * skill_element_rate(element_id) * state_element_rate(element_id)
  end

  #被動技能影響的屬性強化效果。
  def skill_element_damage(element_id)
    skills.inject(1.00) do |plu,skl|
      plu * SkillLevel.formula(self.skill_level(skl.id),skl.element_damage(element_id))
    end
  end

  def state_element_damage(element_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.element_damage(element_id))
    end
  end

  #基礎屬性強化，角色備註和職業備註修正。
  def basic_element_damage(element_id)
    (1.0 + self.actor.element_damage(element_id)/100.0) *
    (1.0 + self.class.element_damage(element_id)/100.0)
  end

  #計算最終屬性強化基礎技能裝備迭代連乘
  def element_damage(element_id)
    basic_element_damage(element_id) *
    equips.compact.inject(skill_element_damage(element_id)) do |rat,equip|
      rat*(1.00+equip.element_damage(element_id)/100.0)
    end
  end

  #受到hp傷害轉移給mp的比例，遍歷計算並返回最大值
  def damage_convert
    skl = skills.collect{|sk| sk = SkillLevel.formula(self.skill_level(sk.id),sk.damage_convert)}
    sta = states.collect{|st| st = SkillLevel.formula(@state_level[st.id],st.damage_convert)}
    (skl+sta).max
  end

  #洗技能了，
  alias item_apply_201411181846 item_apply
  def item_apply(user, item)
    item_apply_201411181846(user, item)
    if item.is_a?(RPG::Item) and item.id == SkillLevel::RESETITEM
      if self.reset_skill
        self.hp = [self.hp,self.mhp].min
        self.mp = [self.mp,self.mmp].min
      end
    end
  end

  #洗技能的方法
  def reset_skill
    return false if self.class.auto_sp
    @sp = (@level-1) * SkillLevel::LEVELUPSP + SkillLevel::INITIALSP
    @skills.each  { |skill| @skill_level[skill]=0 }
    return true
  end

end


class Game_Enemy
  #敵人屬性強化
  def element_damage(id)
    1.0 + self.enemy.element_damage(id)/100.0
  end
  #敵人暴擊倍率 super：Game_Battler定義的critical_rate，返回1.5
  def critical_rate
    super * (1+self.enemy.element_damage/100.0)
  end
  #敵人的技能等級，要麼鎖定，要麼1
  def skill_level(skill_id)
    lock = $data_skills[skill_id].lock_level if $data_skills[skill_id]
    return lock if lock != 0
    return 1
  end
    #狀態提升的基礎屬性（加法疊加的部分）
  def state_param_plus(param_id)
    states.inject(0) do |plu,sta|
      plu + SkillLevel.formula(@state_level[sta.id],sta.param_add(param_id))
    end
  end
  #狀態提升的基礎屬性倍率（乘法疊加）
  def state_param_rate(param_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.param_rate(param_id))
    end
  end
  #狀態額外影響的屬性抗性（乘法疊加）
  def state_element_rate(element_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.element_rate(element_id))
    end
  end

  #基礎屬性的計算，添加了被動技能的提升，按默認的先加後乘
  def param(param_id)
    value = param_base(param_id) + param_plus(param_id) +
            state_param_plus(param_id)
    value *= param_rate(param_id) * param_buff_rate(param_id) *
             state_param_rate(param_id)
    [[value, param_max(param_id)].min, param_min(param_id)].max.to_i
  end

  #狀態影響的附加屬性xparam
  def state_xparam(xparam_id)
    states.inject(0.0) do |plu,sta|
      plu + SkillLevel.formula(@state_level[sta.id],sta.xparam(xparam_id))
    end
  end
  #附加屬性xparam的計算，命中暴擊什麼的，迭代加算。
  def xparam(xparam_id)
    state_xparam(xparam_id) + super(xparam_id)
  end

  #狀態影響特殊屬性sparam的計算
  def state_sparam(sparam_id)
    states.inject(1.0) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.sparam(sparam_id))
    end
  end
  #特殊屬性sparam的計算，經驗值比率什麼的，迭代連乘計算。
  def sparam(sparam_id)
    super(sparam_id)*state_sparam(sparam_id)
  end
  def state_element_damage(element_id)
    states.inject(1.00) do |plu,sta|
      plu * SkillLevel.formula(@state_level[sta.id],sta.element_damage(element_id))
    end
  end
  def element_rate(element_id)
    super(element_id) * state_element_rate(element_id)
  end
end



class Game_Battler < Game_BattlerBase

  #attr_reader :state_level
  #@state_level 保存狀態等級的數組
  alias initialize_201410131453 initialize
  def initialize
    initialize_201410131453
    @state_level = Hash.new(0)
  end

  #屬性修正的計算，將使用者屬性強化也計算在內的
  def item_element_rate(user, item)
    if item.damage.element_id < 0
      user.atk_elements.empty? ? 1.0 : elements_max_rate(user)
    else
      element_rate(item.damage.element_id)*user.element_damage(item.damage.element_id)
    end
  end

  #將使用者屬性強化也計算在內的最有效屬性。
  def elements_max_rate(user)
    user.atk_elements.inject([0.0]) {|r, i| r.push(element_rate(i)*user.element_damage(i)) }.max
  end

  def damage_convert #受到hp傷害轉移給mp的比例
    0
  end

  #計算傷害，SkillLevel.formula找公式算修正。
  def make_damage_value(user, item)
    value = item.damage.eval(user, self, $game_variables)
    if item.is_a?(RPG::Skill)
      #套用在全技能上
      if user.armors.include?($data_armors[16]) && user.state?(2) #毒疫耳環效果
        user.actor? && user.id == 1 ?  value *= 2 : value *= 1#如果是全技能通用只要这两句就可以了 ，其它去掉。
      end

      case item.id
      when 901 #吸血I
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ; $game_variables[100] = value * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.1
      when 902 #吸血II
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.15
      when 903 #吸血III
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.2
      when 904 #吸血IV
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.25
      when 905 #吸血V
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.3

      when 907 #吸魂I
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value  * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.01
      when 908 #吸魂II
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value  * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.02
      when 909 #吸魂III
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value  * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.03
      when 910 #吸魂IV
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value  * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.04
      when 911 #吸魂V
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; $game_variables[100] = value  * (@result.critical ? user.critical_rate : 1) * (user.atk_elements.empty? ? 1 : elements_max_rate(user)) * 0.05

      when 913 #連續I
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def
      when 914 #連續II
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 915 #連續III
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 916 #連續IV
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 917 #連續V
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def

      when 919 #憤怒I
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 920 #憤怒II
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 921 #憤怒III
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 922 #憤怒IV
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 923 #憤怒V
        value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def

      when 925 #累積I
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;  user.add_state(121).to_i
      when 926 #累積II
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;  user.add_state(122).to_i
      when 927 #累積III
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;  user.add_state(123).to_i
      when 928 #累積IV
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;  user.add_state(124).to_i
      when 929 #累積V
        value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;  user.add_state(125).to_i

      when 931 # 狂暴I
       value = item.magical? ? user.mat * 1.2 * (@result.critical ? user.critical_rate : 1) - self.mdf : user.atk * 1.2 * (@result.critical ? user.critical_rate : 1) - self.def
      when 932 # 狂暴II
       value = item.magical? ? user.mat * 1.2 * (@result.critical ? user.critical_rate : 1) - self.mdf : user.atk * 1.2 * (@result.critical ? user.critical_rate : 1) - self.def
      when 933 # 狂暴III
       value = item.magical? ? user.mat * 1.2 * (@result.critical ? user.critical_rate : 1) - self.mdf : user.atk * 1.2 * (@result.critical ? user.critical_rate : 1) - self.def
      when 934 # 狂暴IV
       value = item.magical? ? user.mat * 1.2 * (@result.critical ? user.critical_rate : 1) - self.mdf : user.atk * 1.2 * (@result.critical ? user.critical_rate : 1) - self.def
      when 935 # 狂暴V
       value = item.magical? ? user.mat * 1.2 * (@result.critical ? user.critical_rate : 1) - self.mdf : user.atk * 1.2 * (@result.critical ? user.critical_rate : 1) - self.def

      when 937 # 傳染I
       value = item.magical? ? user.mat * 1.1 - self.mdf : user.atk * 1.1 - self.def ;
                    user.state?(2) ? self.add_state(2).to_i && user.remove_state(2).to_i : nil ; user.state?(3) ? self.add_state(3).to_i && user.remove_state(3).to_i : nil ;
                    user.state?(4) ? self.add_state(4).to_i && user.remove_state(4).to_i : nil ; user.state?(5) ? self.add_state(5).to_i && user.remove_state(5).to_i : nil ;
                    user.state?(6) ? self.add_state(6).to_i && user.remove_state(6).to_i : nil ; user.state?(7) ? self.add_state(7).to_i && user.remove_state(7).to_i : nil ;
                    user.state?(8) ? self.add_state(8).to_i && user.remove_state(8).to_i : nil ;
                    user.state?(16) ? self.add_state(16).to_i && user.remove_state(16).to_i : nil ; user.state?(30) ? self.add_state(30).to_i && user.remove_state(30).to_i : nil ;
                    user.state?(31) ? self.add_state(31).to_i && user.remove_state(31).to_i : nil ; user.state?(32) ? self.add_state(32).to_i && user.remove_state(32).to_i : nil ;
                    user.state?(33) ? self.add_state(33).to_i && user.remove_state(33).to_i : nil ; user.state?(34) ? self.add_state(34).to_i && user.remove_state(34).to_i : nil ;
                    user.state?(35) ? self.add_state(35).to_i && user.remove_state(35).to_i : nil ; user.state?(36) ? self.add_state(36).to_i && user.remove_state(36).to_i : nil ;
                    user.state?(37) ? self.add_state(37).to_i && user.remove_state(37).to_i : nil ; user.state?(57) ? self.add_state(57).to_i && user.remove_state(57).to_i : nil ;
                    user.state?(58) ? self.add_state(58).to_i && user.remove_state(58).to_i : nil ; user.state?(59) ? self.add_state(59).to_i && user.remove_state(59).to_i : nil ;
                    user.state?(60) ? self.add_state(60).to_i && user.remove_state(60).to_i : nil ; user.state?(61) ? self.add_state(61).to_i && user.remove_state(61).to_i : nil ;
                    user.state?(62) ? self.add_state(62).to_i && user.remove_state(62).to_i : nil ; user.state?(63) ? self.add_state(63).to_i && user.remove_state(63).to_i : nil ;
                    user.state?(64) ? self.add_state(64).to_i && user.remove_state(64).to_i : nil ; user.state?(65) ? self.add_state(65).to_i && user.remove_state(65).to_i : nil ;
                    user.state?(66) ? self.add_state(66).to_i && user.remove_state(66).to_i : nil ; user.state?(67) ? self.add_state(67).to_i && user.remove_state(67).to_i : nil ;
                    user.state?(68) ? self.add_state(68).to_i && user.remove_state(68).to_i : nil ; user.state?(69) ? self.add_state(69).to_i && user.remove_state(69).to_i : nil ;
      when 943 # 運氣I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; rand < 0.05 ? user.tp += 100 : nil
      when 944 # 運氣II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; rand < 0.10 ? user.tp += 100 : nil
      when 945 # 運氣III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; rand < 0.15 ? user.tp += 100 : nil
      when 946 # 運氣IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; rand < 0.20 ? user.tp += 100 : nil
      when 947 # 運氣V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; rand < 0.25 ? user.tp += 100 : nil

      when 949 # 擴散I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 950 # 擴散II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 951 # 擴散III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 952 # 擴散IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 953 # 擴散V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def

      when 955 # 代價I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(101)
      when 956 # 代價II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(102)
      when 957 # 代價III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(103)
      when 958 # 代價IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(104)
      when 959 # 代價V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(105)

      when 961 # 付出I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(106)
      when 962 # 付出II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(107)
      when 963 # 付出III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(108)
      when 964 # 付出IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(109)
      when 965 # 付出V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; user.add_state(110)

      when 967 # 鏽蝕I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(111)
      when 968 # 鏽蝕II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(112)
      when 969 # 鏽蝕III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(113)
      when 970 # 鏽蝕IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(114)
      when 971 # 鏽蝕V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(115)

      when 973 # 侵蝕I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(116)
      when 974 # 侵蝕II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(117)
      when 975 # 侵蝕III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(118)
      when 976 # 侵蝕IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(119)
      when 977 # 侵蝕V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def ; self.add_state(120)

      when 979 # 削減I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 980 # 削減II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 981 # 削減III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 982 # 削減IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 983 # 削減V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def

      when 985 # 幸運I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 986 # 幸運II
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 987 # 幸運III
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 988 # 幸運IV
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 989 # 幸運V
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 990 # 幸運效果
       value = user.weapons.include?($data_weapons[137]) || user.weapons.include?($data_weapons[138]) ||
                    user.weapons.include?($data_weapons[139]) || user.weapons.include?($data_weapons[140]) || user.weapons.include?($data_weapons[141]) ? 77 : 0
      when 991 # 竊盜I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 992 # 竊盜I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 993 # 竊盜I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 994 # 竊盜I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def
      when 995 # 竊盜I
       value = item.magical? ? user.mat * 1.2 - self.mdf : user.atk * 1.2 - self.def

       end
    value *= SkillLevel.formula(user.skill_level(item.id),item.damage_increase_type)
    end
    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,user) if @result.critical
    value = apply_variance(value, item.damage.variance)
    value = apply_guard(value)

    if value > 0 && damage_convert > 0
      valmp = [(value*damage_convert).to_i,self.mp].min
      self.mp -= valmp
      value -= valmp
    end
    @result.make_damage(value.to_i, item)
  end

  #計算暴擊修正，添加了參數user
  def apply_critical(value,user)
    value * user.critical_rate
  end

  #基礎暴擊修正
  def critical_rate
    2
  end

  #狀態附加，添加參數user,寫的有點奇怪。如果有明確的user，
  #就提取技能等級user.skill_level($data_states[state_id].link_skill)
  #然後按SkillLevel.formula公式算得到附加概率，如果隨機數比概率大（算是失敗）
  #就直接返回，再下去按部就班如果沒有狀態就附加新狀態，如果有明確的user，
  #狀態的等級就等於之前提取的技能等級，否則為1。
  def add_state(state_id,user = nil)
    if state_addable?(state_id)
      if user != nil
        lv = user.skill_level($data_states[state_id].link_skill)
      else
        lv = 1
      end
      return if rand > SkillLevel.formula(lv,$data_states[state_id].chance)
      add_new_state(state_id) unless state?(state_id)
      # LCTSENG: 狀態疊加
      if $data_states[state_id].accumulate_ok?
        if @state_accumulate.nil?
          @state_accumulate = {}
        end
        if @state_accumulate[state_id].nil?
          @state_accumulate[state_id] = 1
        else
          @state_accumulate[state_id] += 1
        end
        # Max test
        max_accu = $data_states[state_id].accumulate_max
        @state_accumulate[state_id] = [@state_accumulate[state_id], max_accu].min if max_accu > 0
      end
      # Others
      if user != nil
        @state_level[state_id] = lv
      else
        @state_level[state_id] = 1
      end
      reset_state_counts(state_id)
      @result.added_states.push(state_id).uniq!
    end
  end

  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,user)
        @result.success = true
      end
    end
  end

  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,user)
      @result.success = true
    end
  end
end