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
写轮眼
发表于 2019-5-14 10:28:44
收藏
分享
提升卡
沉默号角
喧嚣号角
变色卡
升龙剑
