人物加點和技能加點的衝突

liu5417

人物加點導致技能加點的被動技部份無效, 該怎麼解決呢?

人物加點本身沒問題, 置於技能加點腳本之下(放上面會有問題)

技能不可使用 =  被動技 (沒效果)

技能可使用 = 主動技 (沒問題)

附上範例

Project5.rar (322.02 KB, 下载次数: 58)

2016-12-3 23:10 上传

点击文件名下载附件
範例檔

技能加點
[pre lang="ruby"]#encoding:utf-8
#===========================================================================
#          RMVA 豪華型技能加點|技能被動效果：   v1.05
#                       By希憶 66rpg.com
#                                                 轉載或修改請保留此類信息
#===========================================================================
#     升級獲得技能點用以學習和提升技能等級，增加技能威力和技能被動效果強度。
#     狀態也可以與技能等級綁定，並根據等級不同獲得不同程度的加成效果[類dnf]
#
#     技能的備註：
#     使用場合為"無法使用" 的技能均默認為被動技能，不在戰鬥時出現。
#------------------------------------------------------------------------------------------------------------------------------------
#     <param_add 0,11>
#         0: 被動提升的屬性編號『0:mhp 1:mmp 2:atk 3:def 4:mat 5:mdf 6:agi 7:luk』
#        11：提升量的計算公式編號,在模塊SkillLevel的self.formula方法中定義
#           可根據需要擴展 when 8 when 9 什麼的
#           這個是按加法提升。和下面那個一起寫就是先加後乘。

#     <param_rate 0,31>
#         0：被動提升的屬性編號『0:mhp 1:mmp 2:atk 3:def 4:mat 5:mdf 6:agi 7:luk』
#        31：提升量的計算公式編號,在模塊SkillLevel的self.formula方法中定義
#           這個是按乘法提升。

#     <xparam 0,21>
#         0：被動提升的屬性編號『0:物理命中 1:物理閃避 2:必殺機率 3:必殺閃避
#               4:魔法閃避 5:魔法反射 6:物理反擊 7:體力再生8:魔力再生 9:TP再生 』
#        21：提升量的計算公式編號,在模塊SkillLevel的self.formula方法中定義
#           這個是按加法提升。

#     <sparam 0,31>
#         0：被動提升的屬性編號『0:受擊幾率 1:防禦比率 2:恢復效果 3:藥理知識
#                4:魔力消耗 5:特技補充 6:所受物理傷害 7:所受魔法傷害  8:地形傷害 9：獲得經驗值比率 』                           
#        31：提升量的計算公式編號,在模塊SkillLevel的self.formula方法中定義
#           這個是按乘法提升。
#------------------------------------------------------------------------------------------------------------------------------------
#     <critical_rate 33>
#        33：被動技能提升暴擊傷害的公式，在模塊SkillLevel的self.formula方法中定義
#            按照乘法疊加提升【每個角色職業都有默認的初始值為1.5】
#------------------------------------------------------------------------------------------------------------------------------------
#     <element_rate 3,31>
#         3：被動技能屬性修正的屬性id
#        31：被動技能屬性修正的公式，模塊SkillLevel的self.formula方法中定義
#            按照乘法疊加減少或增加。

#     <element_damage 3,31>
#        31：被動技能提升屬性傷害的公式，提升屬性傷害（就是屬性強化啦）
#            模塊SkillLevel的self.formula方法中定義
#            按照乘法疊加減少或增加。
#------------------------------------------------------------------------------------------------------------------------------------
#     <mp_type 111>
#       111：主動技能的使用時的mp消耗隨著等級變化的公式編號,
#            在模塊SkillLevel的self.formula方法中定義

#     <damage_convert 51>
#        被動獲得hp傷害一部分轉移給mp的效果，同時有兩個以上這種技能或狀態則取最大
#        51：在模塊SkillLevel的self.formula方法中定義的計算轉換比率的公式編號

#     <sp_cost 5>        
#        學習升級一級此技能需要5sp

#     <max_learn 10>
#        技能等級學習上限10級（加點的等級上限）
#        在技能加點欄中技能的基礎等級只能加到10，
#        但是可以通過裝備加技能的裝備來提升到11,12以上

#     <max_level 15>
#        技能等級堆積上限15級（包括了裝備增加的堆積上限）,
#        就是說你裝備了一堆加技能等級的裝備，但這個技能到了15級就沒法再加上去。

#     <type 2>
#        主動技能的技能威力成長類型為第二種（平均增長型）也可以在模塊中自己定義
#        增長類型 self.formula 方法中添加 when 4 when 5 什麼的，然後寫一通公式
#        這裡當然是乘法計算了

#     <learn 10,4>  
#        從10級開始可以學習1級技能，14級可以學到2級，18級可學3級技能
#------------------------------------------------------------------------------------------------------------------------------------
#       前置技能的設置：『學習該技能需要先學習其它的技能到若干級』
#     <former 31,5>  <former 33,1>
#       需要等級5的31號技能和等級1的33號技能作為前置技能
#       前置一行只能設一個，同時設多個請迴車換行
#       前置技能可設可不設，同時設，無上限，搞出個複雜技能樹愉快地玩耍吧
#------------------------------------------------------------------------------------------------------------------------------------
#     <link_skill 24>
#        這個技能鏈接上24號技能，此技能的技能等級將強制等於24號技能的技能等級
#       （無視其它限制，裝備增強無效）
#        小心別連著連著連成循環了，這是給一些特殊的“馬甲技能-實效技能”對應用的。
#        一般情況下別用。

#      <lock_level 4>
#         這個技能的技能等級將強制等於4，優先度高於link_skill
#         主要用於裝備附帶的技能等特殊情況下的技能
#         還有敵方使用的技能，如果需要不為1的話可以這樣設置。

#===========================================================================
#     狀態的備註:

#     <param_add 0,11>
#     <param_rate 0,31>
#     <xparam 0,21>
#     <sparam 0,31>
#     <critical_rate 33>
#     <element_rate 3,31>
#     <element_damage 3,31>
#     <damage_convert 51>
#     同技能，只不過是變成狀態附加時生效並和狀態等級相關

#     <link_skill 122>如果狀態有明確的來源的話狀態的等級將等於來源的122號技能的等級。

#     <chance 43>主要用於debuff，額外的附加幾率修正的公式編號，老規矩

#===========================================================================
#     裝備的備註：
#     <add_skill 10,3>    10號技能等級+3

#    （以下下備註條目也可以備註在角色，職業上，可以為負數（只有以下兩個可以））
#     <critical_rate 10>   必殺傷害 +10%  
#       多個裝備將和職業，角色基礎等乘法疊加
#       基礎暴擊傷害為1.5倍，提升10%就是1.65倍。
#     <element_damage 3,30> 裝備者對敵人使用3號屬性（炎屬性）的攻擊造成的傷害+30%

#===========================================================================
#     職業的備註：
#     <auto_sp>  自動升級技能的職業【不設sp，啥技能都無視前置隨著等級能有多高就多高】
#
#===========================================================================[/pre]
[pre lang="ruby"]#encoding:utf-8
#===========================================================================
#          RMVA 豪华型技能加点|技能被动效果：         v1.05
#                       By希忆 66rpg.com
#                                                 转载或修改请保留此类信息
#===========================================================================
# 模块的设定和被动技能等的实现
#
# 完工？？
#===========================================================================
module SkillLevel
  
  MENUNAME   = "技能书"                       #菜单栏名称
  
  INITIALSP  = 40                             #初始技能点（lv1时的SP点）
  LEVELUPSP  = 30                             #每升一级所获得的技能点
  
  RESETITEM = 23                             #洗点水的物品编号
                                              #洗点水要求目标单个队友，仅菜单可用
  
  def self.formula(level,type)
    case type
  #=========================================================================
  #  这里设定各种乱七八糟的公式，技能威力的成长公式和被动技能属性增加的公式都可以
  #  在这里设定，不过由于计算方式的不同，需要注意别设定错了，数据库里诸如
  #  <param_add 0,11> <type 1> 等都会根据编号（这里分别是11、1）跳转到对应的
  #  when 进行计算，你也可以自己添加分歧，when 65536 什么的。
  #  注意，看清分清乘算加算哦。我写了简单的几个例子。
  #=========================================================================
    when 111
      return 1.00+0.2*level
             #这里写的是默认的技能mp消耗随着等级增加而变化的公式（当然也可以自己写）
    when 0      
      return 0     #加法结算的默认
    when -1
      return 1     #乘法结算的默认
    when 1
      return 1.1**(level-1)                     
                      #可怕的晚成后期神技能  lv5:1.46 lv10:2.358 lv15:3.7975
    when 2
      return 1.00 + 0.15*(level-1)               
                      #普通的平均增长型技能  lv5:1.60 lv10:2.350 lv15:3.1000
    when 3
      return 1.00 + 3.5*(level-1)/(13.7+level)   
                      #早熟的后期低成长技能  lv5:1.75 lv10:2.329 lv15:2.7073
    when 4
      return 1.00 + 0.2*(level-1)   
      
    when 11
      return 20*level                           
      #比较适用于param_add,
      # <param_add 1,11> 每升一级技能等级，MP上限+20
    when 12
      return 4*level
    when 13
      return 3*level
      
    when 21
      return 0.01*level                          
      #比较适用于xparam
      # <xparam 2,21>   每升一级技能等级，必杀机率+1%
    when 22
      return 0.05+0.03*level  
   
    when 23
      return 0 if level == 0
      return 0.005*(level+1)
   
    when 24
      return 0.024*level
      
    when 31
      return 1+0.01*level                        
      #比较适用于param_rate或sparam
      # <param_rate 0,31> 每升一级技能等级，maxhp+1%
      # <sparam :9,31>      每升一级技能等级，所得经验值+1%
    when 32
      return 1-0.01*level   
    when 33
      return 1+0.04*level
    when 34
      return 1-0.02*level
    when 41
      return 0.02*level
    when 43
      return 0 if level == 0
      return 0.07+0.03*level
    when 51
      return 0 if level == 0
      return [1,0.06+level*0.04].min
    when 52
      return level*0.05
    end
   
    return 1                                   
   
  end
  
end


#有关技能的各种正则匹配,注意未匹配时的返回值
class RPG::Skill < RPG::UsableItem

  def sp_cost
    return 0 if auto_levelup
    @note =~ /\<(?:sp_cost) (\d+)\>/ ? $1.to_i : 0
  end
  
  def mp_type
    @note =~ /\<(?:mp_type) (\d+)\>/ ? $1.to_i : 111
  end
  
  def max_learn
    @note =~ /\<(?:max_learn) (\d+)\>/ ? $1.to_i : 0
  end
  
  def max_level
    @note =~ /\<(?:max_level) (\d+)\>/ ? $1.to_i : 1
  end
  
  def damage_increase_type
    @note =~ /\<(?:type) (\d+)\>/ ? $1.to_i : 2
  end
  
  def learn_level
    @note =~ /\<(?:learn) (\d+),(\d+)\>/ ? [$1.to_i,$2.to_i] : [1,1]
  end
  
  def param_add(param_id)
    @note =~ /\<(?:param_add) #{param_id},(\d+)\>/ ? $1.to_i : 0
  end
  
  def param_rate(param_id)
    @note =~ /\<(?:param_rate) #{param_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def xparam(xp_id)
     @note =~ /\<(?:xparam) #{xp_id},(\d+)\>/ ? $1.to_i : 0
  end
  
  def sparam(sparam_id)
    @note =~ /\<(?:sparam) #{sparam_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def critical_rate
    @note =~ /\<(?:critical_rate) (\d+)\>/ ? $1.to_i : -1
  end
  
  def element_rate(element_id)
    @note =~ /\<(?:element_rate) #{element_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def element_damage(element_id)
    @note =~ /\<(?:element_damage) #{element_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def damage_convert
    @note =~ /\<(?:damage_convert) (\d+)\>/ ? $1.to_i : 0
  end
  
  def link_skill
    @note =~ /\<(?:link_skill) (\d+)\>/ ? $1.to_i : 0
  end
  
  def lock_level
    @note =~ /\<(?:lock_level) (\d+)\>/ ? $1.to_i : 0
  end
  
  def auto_levelup
    @note =~ /\<auto_levelup\>/
  end
  
  def former
    val = []
    insert = false
    @note.each_line do |line|
      case line
      when /\<(?:former[1-9]?) (\d+),(\d+)\>/
        val.push([$1.to_i,$2.to_i])
        insert = true
      end
    end
    insert ? val : [[0,0]]
  end
  
  #是否被动技能的标准，使用场合：无法使用
  def passive
    @occasion == 3
  end
  
end

#暴击伤害和属性强化（可以写在数据库的角色备注和职业备注里，也可以写在敌人打到备注里）
class RPG::BaseItem
  
  def critical_rate
    @note =~ /\<(?:critical_rate) (-?[0-9]*)\>/ ? $1.to_i : 0
  end
  
  def element_damage(element_id)
    @note =~ /\<(?:element_rate) #{element_id},(-?[0-9]*)\>/ ? $1.to_i : 0
  end

end

#装备技能等级+x
class RPG::EquipItem

  def add_skill(skill_id)
    @note =~ /\<(?:add_skill) #{skill_id},(\d+)\>/ ? $1.to_i : 0
  end
  
end

#自动升级技能
class RPG::Class < RPG::BaseItem
  def auto_sp
    @note =~ /\<auto_sp\>/
  end
end



class RPG::State < RPG::BaseItem
  
  #这里的link_skill是指状态的对应技能，
  #如果状态有明确的技能来源的话状态的等级将等于
  #来源技能使用者的该id技能的等级。
  def link_skill
    @note =~ /\<(?:link_skill) (\d+)\>/ ? $1.to_i : 0
  end
  
  #额外的几率修正的公式
  #老规矩SkillLevel 的 formula
  def chance
    @note =~ /\<(?:chance) (\d+)\>/ ? $1.to_i : -1
  end
  
  #和技能类似
  def param_add(param_id)
    @note =~ /\<(?:param_add) #{param_id},(\d+)\>/ ? $1.to_i : 0
  end
  
  def param_rate(param_id)
    @note =~ /\<(?:param_rate) #{param_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def xparam(xp_id)
     @note =~ /\<(?:xparam) #{xp_id},(\d+)\>/ ? $1.to_i : 0
  end
  
  def sparam(sparam_id)
    @note =~ /\<(?:sparam) #{sparam_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def critical_rate
    @note =~ /\<(?:critical_rate) (\d+)\>/ ? $1.to_i : -1
  end
  
  def element_rate(element_id)
    @note =~ /\<(?:element_rate) #{element_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def element_damage(element_id)
    @note =~ /\<(?:element_damage) #{element_id},(\d+)\>/ ? $1.to_i : -1
  end
  
  def damage_convert
    @note =~ /\<(?:damage_convert) (\d+)\>/ ? $1.to_i : 0
  end
  
end
#正则匹配篇结束
#=======================================================================





[/pre]
[pre lang="ruby"]#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=0)
    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
  
  #基础属性的计算，添加了被动技能的提升，按默认的先加后乘
  def param(param_id)
    value = param_base(param_id) + param_plus(param_id) +
            skill_plus(param_id) + state_param_plus(param_id)
    value *= param_rate(param_id) * param_buff_rate(param_id) *
             skill_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) + @skills.inject(super(xparam_id)) do |plu,skl|
      plu + SkillLevel.formula(self.skill_level(skl),$data_skills[skl].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 Scene_ItemBase < Scene_MenuBase
  def item_usable?
    if item.id == SkillLevel::RESETITEM
      return false if item_target_actors[0].class.auto_sp
      return true
    end
    user.usable?(item) && item_effects_valid?
  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)
      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
    1.5
  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)
      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





[/pre]
[pre lang="ruby"]#encoding:utf-8
#===========================================================================
#          RMVA 豪华型技能加点|技能被动效果：      v1.05
#                       By希忆 66rpg.com
#                                                 转载或修改请保留此类信息
#===========================================================================
# 所有和窗体有关的修改
#
# 大概没问题吧
#===========================================================================


class Window_BattleSkill < Window_SkillList
# 戰鬥技能視窗顯示
  def include?(item)
    item && !item.passive && item.stype_id == @stype_id && @actor.has_skill?(item)
  end
  
end

class Window_SkillList < Window_Selectable
#默認技能視窗顯示
  def include?(item)
    item && item.stype_id == @stype_id && @actor.has_skill?(item)
  end
  
  def draw_item_name(item, x, y, enabled = true, width = 172)
    return unless item
    draw_icon(item.icon_index, x, y, enabled)
    change_color(normal_color, enabled)
    draw_text(x + 24, y, width, line_height, item.name + " Lv." + @actor.skill_level(item.id).to_s)
  end
  
end

class Window_AllSkill < Window_Selectable

  def initialize(x, y, width, height)
    super
    @actor = nil
    @stype_id = 0
    @data = []
  end
  
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
    self.oy = 0
  end

  def stype_id=(stype_id)
    return if @stype_id == stype_id
    @stype_id = stype_id
    refresh
    self.oy = 0
  end
  
  def col_max
    return 1
  end
  
  def item_max
    @data ? @data.size : 1
  end
  
  def item
    @data && index >= 0 ? @data[index] : nil
  end
  
  def current_item_enabled?
    enable?(@data[index])
  end
  
  def include?(item)
    item && item.stype_id == @stype_id
  end
  
  def enable?(item)
    item != nil && @actor != nil && @actor.skill_can_levelup?(item)
  end

  def make_item_list
    @data = @actor ? @actor.skills.select {|skill| include?(skill) } : []
  end
  
  def select_last
    select(@data.index(@actor.last_skill.object) || 0)
  end
  
  def draw_item(index)
    skill = @data[index]
    if skill
      rect = item_rect(index)
      rect.width -= 4
      draw_skill_name(skill, rect.x, rect.y, enable?(skill))
      draw_skill_level(rect, skill)
    end
  end
  
  def draw_skill_name(skill, x, y, enabled = true, width = 172)
    return unless skill
    draw_icon(skill.icon_index, x, y, enabled)
    change_color(normal_color, enabled)
    text = skill.name
    text += "<已精通>" if @actor.skill_max_learn?(skill)
    draw_text(x + 24, y, width, line_height, text)
  end
  
  def draw_skill_level(rect, skill)
    draw_text(rect, @actor.skill_basic_level(skill.id).to_s, 2)
    change_color(system_color, enable?(skill))
    draw_text(rect, "Lv.     ", 2)
  end
  
  def update_help
    @help_window.set_item(item)
  end
  
  def refresh
    make_item_list
    create_contents
    draw_all_items
  end
end

class Window_Base < Window

#~ draw_text_ex的增强，使其可以自动换行  原作者：叶子 修改：wyongcan
  #--------------------------------------------------------------------------
  # ● 绘制带有控制符的文本内容
  #   如果传递了width参数的话，会自动换行
  #--------------------------------------------------------------------------
  def draw_text_ex(x, y, text, width = nil,textwidth = nil,normalfont = true)
    reset_font_settings if normalfont == true
    text = convert_escape_characters(text)
    pos = {:x => x, :y => y, :new_x => x, :height => calc_line_height(text)}
    if width != nil
      pos[:height] = contents.font.size
      pos[:width] = width
      pos[:textwidth] = textwidth
    end
    process_character(text.slice!(0, 1), text, pos) until text.empty?
  end
  #--------------------------------------------------------------------------
  # ● 文字的处理
  #     c    : 文字
  #     text : 绘制处理中的字符串缓存（字符串可能会被修改）
  #     pos  : 绘制位置 {:x, :y, :new_x, :height}
  #--------------------------------------------------------------------------
  def process_character(c, text, pos)
    case c
    when "\r"   # 回车
      return
    when "\n"   # 换行
      process_new_line(text, pos)
    when "\f"   # 翻页
      process_new_page(text, pos)
    when "\e"   # 控制符
      process_escape_character(obtain_escape_code(text), text, pos)
    else        # 普通文字
      pos[:textwidth] == nil ? text_width = text_size(c).width : text_width = pos[:textwidth]
      if pos[:width] != nil && pos[:x] - pos[:new_x] + text_width > pos[:width]
        process_new_line(text, pos)
      end
      process_normal_character(c, pos)
    end
  end
end

class Window_SkillStatus < Window_Base
  
  def initialize(x, y)
    super(x, y, window_width, fitting_height(4))
    @actor = nil
  end
  
  def window_width
    Graphics.width - 160
  end
  
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end

  def draw_actor_sp(actor,x,y)
    change_color(system_color)
    draw_text(x, y, 200, line_height, "SP:")
    change_color(normal_color)
    draw_text(x+48, y, 200, line_height, actor.sp)
  end
  
  def refresh
    contents.clear
    return unless @actor
    draw_actor_face(@actor, 0, 0)
    draw_actor_simple_status(@actor, 108, line_height / 2)
    draw_actor_sp(@actor,108,64)
  end
end



class Window_AddHelp < Window_Base
  def initialize(x, y, width, height)
    super
    @skill = nil
    @actor = nil
    refresh
  end

  def set_item(skill)
    return if @skill == skill
    @skill = skill
    refresh
  end
  
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  def line_width
    Graphics.width/2-standard_padding*2
  end
  def draw_skill_name(skill,x,y)
    draw_icon(skill.icon_index, x, y)
    change_color(normal_color)
    draw_text(x+24, y, line_width, line_height, skill.name)
    if skill.passive
      draw_text(x, y, line_width, line_height, "被動技能",2)
    else
      change_color(mp_cost_color)
      draw_text(x, y, line_width, line_height, "MP "+@actor.skill_mp_cost(skill).to_s,2)
    end
  end
  
  def draw_skill_level(skill,x,y)
    change_color(system_color)
    draw_text(x, y, line_width, line_height,"Level ")
    text =@actor.skill_basic_level(skill.id).to_s + "/"+skill.max_learn.to_s
    change_color(normal_color)
    draw_text(x+60, y, line_width-60, line_height,text)
    draw_text(x, y, line_width, line_height,"升级所需SP: "+skill.sp_cost.to_s,2)
  end
  def draw_next_level(skill,x,y)
    if skill.link_skill != 0
      change_color(knockout_color)
      draw_text(x, y, line_width, line_height,"绑定技能："+$data_skills[skill.link_skill].name)
      return
    end
    lvl = @actor.skill_next_level(skill)
    if !lvl
      change_color(system_color)
      draw_text(x, y, line_width, line_height,"已精通。")
    else
      if @actor.level >= @actor.skill_next_level(skill)
        change_color(normal_color)
      else
        change_color(crisis_color)
      end
      draw_text(x, y, line_width, line_height,"需要等级: "+lvl.to_s)
    end
  end
  def draw_former_skill(skill,x,y)
    line = 0
    skill.former.each do |former|
      if former[0] != 0
        txt = "需要: " + $data_skills[former[0]].name + "|Lv.#{former[1]}"
        @actor.skill_basic_level(former[0]) >= former[1] ? change_color(system_color) : change_color(crisis_color)
        draw_text(x, y+line*line_height, line_width, line_height,txt)
        line += 1
      end
    end
    line
  end
  def refresh
    contents.clear
    return if @skill == nil or @actor == nil
    draw_skill_name(@skill,0,0)
    draw_skill_level(@skill,0,line_height)
    draw_next_level(@skill,0,line_height*2)
    n = draw_former_skill(@skill,0,line_height*3)
    draw_text_ex(0, line_height*(3+n), @skill.description, line_width)
  end
  
end



#==============================================================================
# ■ Window_AddCommand
#------------------------------------------------------------------------------
# 　
#==============================================================================
class Window_AddCommand < Window_Command
  
  def initialize
    super(100, 120)
    self.visible = false
    self.active = false
    @index = 0
  end
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
    add_command("提升一级",   :add1)
    add_command("提升满",    :addf)
    add_command("取消",    :cancel)
  end
  #--------------------------------------------------------------------------
  # ● 決定ボタンが押されたときの処理
  #--------------------------------------------------------------------------
  def process_ok
    Input.update
    call_ok_handler
  end
  #--------------------------------------------------------------------------
  # ● 按下取消键时的处理
  #--------------------------------------------------------------------------
  def process_cancel
    Input.update
    call_cancel_handler
  end
  #--------------------------------------------------------------------------
  # ● 启用窗口
  #--------------------------------------------------------------------------
  def activate
    temp = self.y + self.height - Graphics.height
    if temp > 0
      self.y -= Graphics.height - self.height
    end
    self.active = true
    self
  end
end
[/pre]
[pre lang="ruby"]#encoding:utf-8
#===========================================================================
#      RMVA 豪华技能加点|技能被动效果：         v1.05
#                       By希忆 66rpg.com
#                                                 转载或修改请保留此类信息
# 所有和场景相关的修改
# 应该没啥要处理的了。
#===========================================================================
class Scene_AddSkill < Scene_MenuBase
  #--------------------------------------------------------------------------
  # ● 开始处理
  #--------------------------------------------------------------------------
  def start
    super
    create_command_window
    create_status_window
    create_help_window
    create_item_window
    @add_command = Window_AddCommand.new
    @add_command.viewport = @viewport
    @add_command.set_handler(:add1,    method(:command_add1))
    @add_command.set_handler(:addf,    method(:command_addf))
    @add_command.set_handler(:cancel,    method(:command_canc))
  end
  def create_help_window
    wx = Graphics.width/2
    wy = @status_window.height
    wh = Graphics.height - wy
    @help_window = Window_AddHelp.new(wx,wy,wx,wh)
    @help_window.viewport = @viewport
    @help_window.actor = @actor
  end
  #--------------------------------------------------------------------------
  # ● 生成指令窗口
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_SkillCommand.new(0, 0)
    @command_window.viewport = @viewport
    @command_window.help_window = @help_window
    @command_window.actor = @actor
    @command_window.set_handler(:skill,    method(:command_skill))
    @command_window.set_handler(:cancel,   method(:return_scene))
    @command_window.set_handler(:pagedown, method(:next_actor))
    @command_window.set_handler(:pageup,   method(:prev_actor))
   
  end
  
  def command_add1
    @actor.level_up_skill(@item_window.item.id)
    @item_window.refresh
    @help_window.refresh
    @status_window.refresh
    Sound.play_ok
    @add_command.hide
    @add_command.deactivate
    @item_window.activate
    @item_window.index = @item_index
  end
  def command_addf
    while @actor.level_up_skill(@item_window.item.id)
    end
    @item_window.refresh
    @help_window.refresh
    @status_window.refresh
    Sound.play_ok
    @add_command.hide
    @add_command.deactivate
    @item_window.activate
    @item_window.index = @item_index
  end
  def command_canc
    Sound.play_cancel
    command_skill
  end
  
  def update
    super
    @add_command.y =[120 + @item_window.index * 24,Graphics.height - @add_command.height].min
  end
  
  #--------------------------------------------------------------------------
  # ● 生成状态窗口
  #--------------------------------------------------------------------------
  def create_status_window
    @status_window = Window_SkillStatus.new(@command_window.width, 0)
    @status_window.viewport = @viewport
    @status_window.actor = @actor
  end
  #--------------------------------------------------------------------------
  # ● 生成物品窗口
  #--------------------------------------------------------------------------
  def create_item_window
    wx = 0
    wy = @status_window.height
    ww = Graphics.width/2
    wh = Graphics.height - wy
    @item_window = Window_AllSkill.new(wx, wy, ww, wh)
    @item_window.actor = @actor
    @item_window.viewport = @viewport
    @item_window.help_window = @help_window
    @item_window.set_handler(:ok,     method(:on_item_ok))
    @item_window.set_handler(:cancel, method(:on_item_cancel))
    @command_window.skill_window = @item_window
  end
  #--------------------------------------------------------------------------
  # ● 指令“技能”
  #--------------------------------------------------------------------------
  def command_skill
    @add_command.hide
    @add_command.deactivate
    @item_window.activate
    @item_window.select_last
  end
  #--------------------------------------------------------------------------
  # ● 物品“确定”
  #--------------------------------------------------------------------------
  def on_item_ok
    @item_index = @item_window.index
    @add_command.show
    @add_command.activate
  end
  #--------------------------------------------------------------------------
  # ● 物品“取消”
  #--------------------------------------------------------------------------
  def on_item_cancel
    @item_window.unselect
    @command_window.activate
  end

  #--------------------------------------------------------------------------
  # ● 切换角色
  #--------------------------------------------------------------------------
  def on_actor_change
    @command_window.actor = @actor
    @status_window.actor = @actor
    @item_window.actor = @actor
    @help_window.actor = @actor
    @command_window.activate
  end
end



#===========================================================================
# 向菜单中添加
#===========================================================================

class Window_MenuCommand < Window_Command
  alias add_original_commands_201411160131 add_original_commands
  def add_original_commands
    add_original_commands_201411160131
    add_command(SkillLevel::MENUNAME, :addskill, main_commands_enabled)
  end
end


class Scene_Menu < Scene_MenuBase
  alias create_command_window_201411160131 create_command_window
  def create_command_window
    create_command_window_201411160131
    @command_window.set_handler(:addskill,      method(:command_personal))
  end
  def on_personal_ok
    case @command_window.current_symbol
    when :skill
      SceneManager.call(Scene_Skill)
    when :equip
      SceneManager.call(Scene_Equip)
    when :status
      SceneManager.call(Scene_Status)
    when :addskill
      SceneManager.call(Scene_AddSkill)
    end
  end
end[/pre]

人物加點
[pre lang="ruby"]#encoding:utf-8
#=============================================================================
#-----------RMVA加点系统正常向-v1.03---By：救世小树--------转载请注明出处-------
#=============================================================================

module Point_Tree
  
  POINT_KIND     = 6     #设定加点种类
  LEVEL_UP_POINT = 2       #每升一级自由属性点增加数
  RESET_ITEM     = 29      #洗点水编号
  
  #$game_actors[n].point[0]+=x
  #n为角色ID，x为增加的未分配点数
  
  STR_POINT        = ["生命","精神","力量","耐力","敏捷","抗性"]
  
  #分别对应增加       [MHP,MMP,物攻,物防,魔攻,魔防,敏捷,幸运]
  POINT_ADD_PARAM = [
                     [1 ,  0,   0,  0,   0,   0,   0,   0],     #体力
                     [0  , 1,   0,  0,   0,   0,   0,   0],     #精神
                     [0  ,  0,   1,  0,   1,   0,   0,   0],     #力量
                     [0  , 0,   0,  1,   0,   1,   0,   0],     #耐力
                     [0  ,  0,   0,  0,   0,   0,   1,   0],     #灵活
                     [0  ,  0,   0,  0,   0,   0,   0,   1],     #韧性
                     
                     [0,0,0,0,0,0,0,0]]
                     #可以按上面的格式添加下去，不过要改POINT_KIND，STR_ALL，不然加了也白加
  
  #分别对应增加       [物理命中,物理闪避,必杀,必杀闪避,魔法闪避,魔法反射,物理反击,HP再生,Mp再生,Tp再生]
  POINT_ADD_XPARAM = [
                      [0 , 0, 0, 0, 0, 0, 0, 5, 0, 0],  #体力
                      [0 , 0, 0, 0, 0, 0, 0, 0, 5, 0],  #精神
                      [0 , 0, 5, 0, 0, 0, 0, 0, 0, 0],  #力量
                      [0 , 0, 0, 0, 0, 0, 0, 0, 0, 5],  #耐力
                      [0 , 5, 0, 0, 0, 0, 0, 0, 0, 0],  #灵活
                      [5 , 0, 0, 0, 0, 0, 0, 0, 0, 0],  #韧性
                     
                      [0,0,0,0,0,0,0,0,0,0]]
                     #这里的单位是万分之一数值也就是0.01%，我随便填了下【别嫌小，够大了，有心情你可以算算看平衡性】
  
  #各种名称
  
  ADDPOINT       = "加點"     #菜单中选项
  POINT_NAME     = "Ap"   #未分配点数
  
  XARAM_NAME     = ["命中率","迴避率","爆擊率","必杀闪避","魔法闪避","魔法反射","物理反击","HP再生","Mp再生","Tp再生"]

  
  def temp_all
    r = 0
    for i in 0 .. POINT_KIND-1
      r+=$temp_point
    end
    return r
  end
  
  def reset(actor_id)
    for i in 1..6
      $game_actors[actor_id].point[0] += $game_actors[actor_id].point
      $game_actors[actor_id].point =0
    end
  end
  
end

$temp_point = []
for i in 0 .. Point_Tree::POINT_KIND-1
  $temp_point.push(0)
end

class Game_Actor < Game_Battler
  include Point_Tree
  attr_accessor :point
  
  alias setup_tre setup
  def setup(actor_id)
    @point = []
    for i in 0 .. POINT_KIND
      @point.push(0)
    end
    setup_tre(actor_id)
  end
  
  
  
  
  alias level_up_tre level_up
  def level_up
    level_up_tre
    @hp += mhp
    @mp += mmp
    @point[0] += LEVEL_UP_POINT
  end

  
  
  def point_plus(param_id)
    r=0
    for i in 1 .. POINT_KIND
      r+=@point*POINT_ADD_PARAM[i-1][param_id]
    end
    return r
  end

  alias point_base_param param
  
  def param(param_id)
    value = param_base(param_id) + param_plus(param_id) + point_plus(param_id)
    value *= param_rate(param_id) * param_buff_rate(param_id)
    [[value, param_max(param_id)].min, param_min(param_id)].max.to_i
  end
  def xparam(xparam_id,extra_add = 0)
    xp = super(xparam_id)
    for i in 0 .. POINT_KIND-1
      xp+=(@point[i+1]*POINT_ADD_XPARAM[xparam_id]/10000.0)
    end
    return xp
  end

  def item_apply(user, item)
    super(user, item)
    if item.id == RESET_ITEM and item.is_a?(RPG::Item)
      reset(@actor_id)
      self.hp = [self.hp,self.mhp].min
      self.mp = [self.mp,self.mmp].min
    end
  end
  
end

class Window_Point_Command < Window_Command
  
  include Point_Tree
  #--------------------------------------------------------------------------
  # ● 初始化指令选择位置（类方法）
  #--------------------------------------------------------------------------
  def self.init_command_position
    @@last_command_symbol = nil
  end
  #--------------------------------------------------------------------------
  # ● 初始化对象
  #--------------------------------------------------------------------------
  def initialize(actor)
    @status_window = nil
    @actor = actor
    super(0,0)
    select_last
  end
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  def status_window=(status_window)
    return if @status_window == status_window
    @status_window = status_window
  end
  #--------------------------------------------------------------------------
  # ● 获取窗口的宽度
  #--------------------------------------------------------------------------
  def window_width
    return 160
  end
  #--------------------------------------------------------------------------
  # ● 获取显示行数
  #--------------------------------------------------------------------------
  def visible_line_number
    item_max
  end
  def get_actor_point(index)
    s = @actor.point[index+1].to_s
    return "("+s+")+"+$temp_point[index].to_s
  end
  #--------------------------------------------------------------------------
  # ● 生成指令列表
  #--------------------------------------------------------------------------
  def make_command_list
    for i in 0 .. POINT_KIND-1
      add_command(STR_POINT   + get_actor_point(i)  , :point_add  ,add_enabled)
    end
    add_command("确认",  :point_ok)
    add_command("取消",  :point_cancle)
  end
  #--------------------------------------------------------------------------
  # ● 按下确定键时的处理
  #--------------------------------------------------------------------------
  def process_ok
    @@last_command_symbol = current_symbol
    super
  end
  #--------------------------------------------------------------------------
  # ● 返回最后一个选项的位置
  #--------------------------------------------------------------------------
  def select_last
    select_symbol(@@last_command_symbol)
  end
  
  def add_enabled
    temp_all < @actor.point[0]
  end

  def update_help
    @help_window.set_text(self.index+1) if @help_window
    @status_window.index = self.index if @status_window
  end
end

#帮助窗口
class Window_Point_Help < Window_Base
  include Point_Tree
  def initialize(x,y,w,h)
    super(x, y, w, h)
   
   
  end
  def set_text(id)
    contents.clear
    if id <= POINT_KIND
      text = "\\}提升一点该属性"
    elsif id == POINT_KIND+1
      text = "\\}确认此次加点分配"
    elsif  id == POINT_KIND+2
      text = "\\}取消此次加点分配"
    end
    draw_text_ex(8, 8, text)
  end
end


#角色状态窗口
class Window_Point_Actor < Window_Base
  include Point_Tree
  
  
  def initialize(actor)
    super(160, 0, Graphics.width - 160, Graphics.height)
    @actor = actor
    @index = 0
    refresh
  end
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  def index=(index)
    return if @index == index
    @index = index
    refresh
  end
  def line_height
    return 24
  end
  def refresh
    contents.clear
    contents.font.size = 24
    draw_actor_name(@actor, 100, 0)
    draw_actor_class(@actor, 240, 0)
    draw_actor_face(@actor, 2, 0)
    contents.font.size = 20
    draw_actor_level(@actor, 102,  24)
    draw_actor_point(100,48)
    contents.font.size = 16
    draw_actor_param_point(8,16 * 6)
    draw_actor_xparam_point(8,16 * 14)
  end
  def draw_actor_point(x,y)
    draw_text(x,y,200,line_height,"  未分配"+POINT_NAME + ":" + @actor.point[0].to_s)
    draw_text(x,y+line_height,200,line_height,"此次分配"+POINT_NAME + ":" + temp_all.to_s)
  end
  def draw_actor_param_point(x,y)
    8.times {|i| draw_actor_param_to_s(x,y,i)}
  end
  def draw_actor_xparam_point(x,y)
    10.times {|i| draw_actor_xparam_to_s(x,y,i)}
  end
  
  def draw_actor_param_to_s(x,y,param_id)
    a=0
    for i in 0 .. POINT_KIND-1
      a+=$temp_point*POINT_ADD_PARAM[param_id]
    end
    s1 = Vocab::param(param_id)
    s2 = @actor.param(param_id).to_s
    s3 = (@actor.param(param_id)+a).to_s
    if @index < POINT_KIND
      if POINT_ADD_PARAM[@index][param_id]==0
        s4 = ""
      else
        s4 = "+" + POINT_ADD_PARAM[@index][param_id].to_s
      end
    else
      s4 = ""
    end
   
    change_color(system_color)
    draw_text(x,y+16*param_id,100,line_height,s1)
    change_color(normal_color)
    s2+= " →"
    draw_text(x+82,y+16*param_id,120,line_height,s2,2)
    change_color(system_color)
    draw_text(x+150,y+16*param_id,100,line_height,s3,2)
    change_color(normal_color)
    contents.font.size = 14
    draw_text(x+266,y+16*param_id,100,line_height,s4)
    contents.font.size = 16
  end
  def draw_actor_xparam_to_s(x,y,xparam_id)
    a=0.00
    for i in 0 .. POINT_KIND-1
      a+=($temp_point*POINT_ADD_XPARAM[xparam_id]/10000.0)
    end
    s1 = XARAM_NAME[xparam_id]
    s2 = sprintf("%02.2f%%",@actor.xparam(xparam_id)*100)
    s3 = sprintf("%02.2f%%",(@actor.xparam(xparam_id) + a)*100)

    if @index < POINT_KIND
      if POINT_ADD_XPARAM[@index][xparam_id]==0
        s4=""
      else
        s4 = sprintf("+%02.2f%%",POINT_ADD_XPARAM[@index][xparam_id]/100.0)
      end
    else
      s4 = ""
    end
   
    change_color(system_color)
    draw_text(x,y+16*xparam_id,100,line_height,s1)
    change_color(normal_color)
    s2+= " →"
    draw_text(x+82,y+16*xparam_id,120,line_height,s2,2)
    change_color(system_color)
    draw_text(x+150,y+16*xparam_id,100,line_height,s3,2)
    change_color(normal_color)
    contents.font.size = 14
    draw_text(x+266,y+16*xparam_id,100,line_height,s4)
    contents.font.size = 16
   
   
  end
end

class Scene_Point < Scene_Base
  include Point_Tree
  def start
    super
    create_background
    @actor = $game_party.menu_actor
    create_command_window
    create_status_window
    create_help_window
    @command_window.activate
  end
  def terminate
    super
    dispose_background
  end
  def create_background
    @background_sprite = Sprite.new
    @background_sprite.bitmap = SceneManager.background_bitmap
    @background_sprite.color.set(16, 16, 16, 128)
  end
  def dispose_background
    @background_sprite.dispose
  end
  
  def create_command_window
    @command_window = Window_Point_Command.new(@actor)
    @command_window.set_handler(:cancel,      method(:return_scene))
    @command_window.set_handler(:pagedown,    method(:next_actor))
    @command_window.set_handler(:pageup,      method(:prev_actor))
    @command_window.set_handler(:point_add,   method(:add_point))
    @command_window.set_handler(:point_ok,    method(:add_ok))
    @command_window.set_handler(:point_cancle,method(:add_cancle))
   
  end
  def return_scene
    add_cancle
    SceneManager.return
  end
  def create_status_window
    @status_window = Window_Point_Actor.new(@actor)
    @command_window.status_window = @status_window
  end
  def create_help_window
    @help_window = Window_Point_Help.new(0,@command_window.height,160,Graphics.height-@command_window.height)
    #(0, 216, 160, 200)
    @help_window.viewport = @viewport
    @command_window.help_window = @help_window
  end
  
  def add_point
    if temp_all >= @actor.point[0]
      @command_window.activate
      return
    end
    $temp_point[@command_window.index] += 1
    @status_window.refresh
    @command_window.refresh
    @command_window.activate
  end
  

  def add_ok
    for i in 0 .. POINT_KIND-1
      @actor.point[i+1] += $temp_point
    end
    @actor.point[0]-= temp_all
    add_cancle
  end
  
  def add_cancle
    for i in 0 .. POINT_KIND-1
      $temp_point=0
    end
    @status_window.refresh
    @command_window.refresh
    @command_window.activate
  end
  
  
  def next_actor
    @actor = $game_party.menu_actor_next
    on_actor_change
  end
  #--------------------------------------------------------------------------
  # ● 切换到上一个角色
  #--------------------------------------------------------------------------
  def prev_actor
    @actor = $game_party.menu_actor_prev
    on_actor_change
  end
  #--------------------------------------------------------------------------
  # ● 切换角色
  #--------------------------------------------------------------------------
  def on_actor_change
    add_cancle
    @status_window.actor = @actor
    @command_window.actor = @actor
    @command_window.activate
  end
  
end

class Window_MenuCommand < Window_Command
  alias add_original_commands_old add_original_commands
  def add_original_commands
    add_original_commands_old
    add_command(Point_Tree::ADDPOINT,    :addpoint)
  end
end

class Scene_Menu < Scene_MenuBase
  alias create_command_window_old create_command_window
  def create_command_window
    create_command_window_old
    @command_window.set_handler(:addpoint,method(:add_point))
  end
  def add_point
    @status_window.select_last
    @status_window.activate
    @status_window.set_handler(:ok,     method(:on_ok))
    @status_window.set_handler(:cancel, method(:on_personal_cancel))
  end
  def on_ok
    SceneManager.call(Scene_Point)
    Window_Point_Command::init_command_position
  end
end



class Scene_ItemBase < Scene_MenuBase
  def item_usable?
    if item.id == Point_Tree::RESET_ITEM and item.is_a?(RPG::Item)
      return true
    end
    user.usable?(item) && item_effects_valid?
  end
end




#===============================================================
#顯示在介面上
#===============================================================
=begin
class Window_Status < Window_Selectable
  include Point_Tree
  alias draw_parameters_old draw_parameters
  def draw_parameters(x, y)
    draw_parameters_old(x,y)
    draw_point(x,y)
  end
  def draw_point(x,y)
    for i in 0..5
      change_color(system_color)
      draw_text(x+100, y+ line_height * i, 80, line_height, STR_POINT)
      change_color(normal_color)
      draw_text(x+180, y+ line_height * i, 36, line_height,@actor.point[i+1].to_s, 2)
    end
  end
  
end

class Window_Base < Window
  def draw_actor_param(actor, x, y, param_id)
    change_color(system_color)
    draw_text(x-30, y, 80, line_height, Vocab::param(param_id))
    change_color(normal_color)
    draw_text(x+ 50, y, 36, line_height, actor.param(param_id), 2)
  end
end
=end[/pre]