| 赞 | 3 |
| VIP | |
| 好人卡 | |
| 积分 | 22 |
| 经验 | |
| 最后登录 | 2025-7-3 |
| 在线时间 | 1015 小时 |
- 梦石
- 0
- 星屑
- 2245
- 在线时间
- 1015 小时
- 注册时间
- 2015-10-17
- 回帖
- 1077
|
加入我们,或者,欢迎回来。
您需要 登录 才可以下载或查看,没有账号?注册会员
×
下面两个脚本,只能生效一个,如何让两个都起效果,知道的告诉下,谢谢
- class Game_Actor < Game_Battler
-
- #--------------------------------------------------------------------------
- # ● 通常能力値の取得
- #--------------------------------------------------------------------------
- def param(param_id)
- super(param_id) - (spirit? ? Spirits::PRM_BASE[param_id] : 0)
- end
- alias org_param param
- def param(param_id)
- org = org_param(param_id)
- if has_spirit?
- partners_objs.each do |s|
- org += Spirits.affinity_param(s.org_param(param_id), @actor_id, s.spirit_id)
- end
- end
- org
- end
复制代码
- 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
复制代码 |
|