查看: 3148|回复: 0

[已经过期] 战斗卡顿

[复制链接]
梦石
0
星屑
2245
在线时间
1015 小时
注册时间
2015-10-17
回帖
1077
发表于 2019-5-11 18:56:05 | 显示全部楼层 |阅读模式

加入我们,或者,欢迎回来。

您需要 登录 才可以下载或查看,没有账号?注册会员

×
用了下面脚本后,战斗有点卡顿,帮忙看下哪里的问题,谢谢

  1. #encoding:utf-8
  2. #===========================================================================
  3. #          RMVA 豪华型技能加点|技能被动效果:        v1.05
  4. #                       By希忆 66rpg.com
  5. #                                                 转载或修改请保留此类信息
  6. #===========================================================================
  7. # 在游戏系统类的实现
  8. #
  9. # 完工了,大概
  10. #===========================================================================
  11. #角色类,新增一堆方法。
  12. class Game_Actor < Game_Battler
  13.   
  14.   #初始化角色
  15.   #@skill_level:存放技能等级数据的哈希表,技能id=>技能等级
  16.   #@sp:剩余技能点
  17.   alias setup_201410131453 setup
  18.   def setup(actor_id)
  19.     @skill_level=Hash.new(0)
  20.     setup_201410131453(actor_id)
  21.     @sp = (@level-1) * SkillLevel::LEVELUPSP + SkillLevel::INITIALSP
  22.     auto_skill_levelup if self.class.auto_sp
  23.   end
  24.   
  25.   #读取技能点的方法,如果是自动升级技能的职业,则没必要有技能点
  26.   def sp
  27.     return 0 if self.class.auto_sp
  28.     @sp
  29.   end
  30.   
  31.   #读取技能基础等级,
  32.   #锁定技能等级优先度最高,
  33.   #链接技能等级次之,这个我好像在计算技能最终等级的方法里面又来了一遍。
  34.   #主要是技能基础等级是升级技能的窗口看到的等级,最终等级是使用技能的窗口。
  35.   def skill_basic_level(skill_id)
  36.     return 0 if skill_id == 0
  37.     lock = $data_skills[skill_id].lock_level
  38.     return lock if lock != 0
  39.     lnk = $data_skills[skill_id].link_skill
  40.     return skill_basic_level(lnk) if lnk != 0
  41.     @skill_level[skill_id]
  42.   end
  43.   
  44.   #获取装备增加技能的等级之和
  45.   def skill_plus_level(skill_id)
  46.     self.equips.compact.inject(0){|skl,eqp| skl+eqp.add_skill(skill_id)}
  47.   end
  48.   
  49.   #读取技能最终等级,如果技能基础等级为零,则不加装备提升直接等于零。
  50.   #最后返回基础等级+装备附加与技能最大等级中的小值
  51.   def skill_level(skill_id)
  52.     return 0 if skill_id == 0
  53.     lock = $data_skills[skill_id].lock_level
  54.     return lock if lock != 0
  55.     lnk = $data_skills[skill_id].link_skill
  56.     return skill_level(lnk) if lnk != 0
  57.     return 0 unless @skills.include?(skill_id)
  58.     return 0 if skill_basic_level(skill_id) == 0
  59.     [skill_basic_level(skill_id) + skill_plus_level(skill_id) ,\
  60.     $data_skills[skill_id].max_level].min
  61.   end
  62.   
  63.   #升一级技能技能能升级就升级,返回成功,否则返回失败
  64.   def level_up_skill(skill_id)
  65.     skl = $data_skills[skill_id]
  66.     if skill_can_levelup?(skl)
  67.       @sp -= skl.sp_cost
  68.       @skill_level[skill_id] += 1
  69.       return true
  70.     else
  71.       return false
  72.     end
  73.   end
  74.   
  75.   #初始化角色时初始化技能的方法,
  76.   #这里是不管默认的技能设定直接加载能学到的所有技能,也就是职业列表下的那些。
  77.   def init_skills
  78.     @skills = []
  79.     self.class.learnings.each do |learning|
  80.       @skills.push(learning.skill_id)
  81.     end
  82.     @skills.sort!
  83.   end
  84.   
  85.   #主要用在技能列表的窗口里的。确保只有技能等级为1级及以上的技能才能显示。
  86.   def has_skill?(skill)
  87.     skills.include?(skill) && skill_basic_level(skill.id) >= 0
  88.   end
  89.   
  90.   #判断是否学习了技能,同样要确保只有技能等级为1级及以上的技能才能显示。
  91.   #和上面的区别是上面的可以有装备附带,状态附带的技能等级不为0的技能
  92.   #这里只能是职业列表下“领悟”的技能,装备状态附带的都不算
  93.   def skill_learn?(skill)
  94.     skill.is_a?(RPG::Skill) && @skills.include?(skill.id) && skill_basic_level(skill.id) >= 0
  95.   end
  96.   
  97.   #判断前置技能是否都满足
  98.   def skill_former_match?(skill)
  99.     skill.former.each do |former|
  100.       return false unless skill_basic_level(former[0]) >= former[1]
  101.     end
  102.     true
  103.   end
  104.   
  105.   #判断技能是否已经学到精通了、
  106.   def skill_max_learn?(skill)
  107.     skill_basic_level(skill.id) == skill.max_learn
  108.   end
  109.   
  110.   #计算学习下一等级的技能所需要的人物等级
  111.   #如果精通了return false【感觉好像有点奇葩。。。】
  112.   def skill_next_level(skill)
  113.     return false if skill_max_learn?(skill)
  114.     skill.learn_level[0] + skill_basic_level(skill.id) * skill.learn_level[1]
  115.   end
  116.   
  117.   #技能能否升级?首先看是否锁定,是否链接,是否精通,
  118.   #再看等级是否符合学习下一级,sp是否足够,前置技能是否满足要求。
  119.   def skill_can_levelup?(skill)
  120.     return false if skill.lock_level != 0
  121.     return false if skill.link_skill != 0
  122.     return false if skill_max_learn?(skill)
  123.     @level >= skill_next_level(skill) && @sp >= skill.sp_cost && skill_former_match?(skill)
  124.   end
  125.   
  126.   #好像没什么用处。。。当初修改的用意是直接设置技能等级,后来觉得不好控制。。。
  127.   #反正就放着吧,不去管它好了
  128.   def learn_skill(skill_id,sk_level=0)
  129.     unless skill_learn?($data_skills[skill_id])
  130.       @skills.push(skill_id)
  131.       @skills.sort!
  132.       @skill_level[skill_id]=sk_level unless @skill_level.has_key?(skill_id)
  133.     end
  134.   end
  135.   
  136.   #自动升级技能。
  137.   def auto_skill_levelup
  138.     @skills.each do |skill|
  139.       skl=$data_skills[skill]
  140.       if self.class.auto_sp
  141.         while skill_next_level(skl) && skill_next_level(skl) <= @level do
  142.           @skill_level[skill] += 1
  143.         end
  144.       elsif skl.auto_levelup
  145.         while level_up_skill(skill) do
  146.         end
  147.       end
  148.     end
  149.   end
  150.   
  151.   #升级时发生的事情,等级+1,sp增加,如果是自动升级技能的职业则自动升级技能
  152.   def level_up
  153.     @level += 1
  154.     @sp += SkillLevel::LEVELUPSP
  155.     auto_skill_levelup
  156.   end
  157.   
  158.   #被动技能提升的基础属性(加法叠加的部分)
  159.   #SkillLevel.formula:带入公式计算。
  160.   def skill_plus(param_id)
  161.     skills.inject(0) do |plu,skl|
  162.       plu + SkillLevel.formula(self.skill_level(skl.id),skl.param_add(param_id))
  163.     end
  164.   end
  165.   
  166.   #被动技能提升的基础属性倍率(乘法叠加)
  167.   def skill_rate(param_id)
  168.     skills.inject(1.00) do |plu,skl|
  169.       plu * SkillLevel.formula(self.skill_level(skl.id),skl.param_rate(param_id))
  170.     end
  171.   end
  172.   
  173.   #被动技能影响的属性抗性(乘法叠加)
  174.   def skill_element_rate(element_id)
  175.     skills.inject(1.00) do |plu,skl|
  176.       plu * SkillLevel.formula(self.skill_level(skl.id),skl.element_rate(element_id))
  177.     end
  178.   end
  179.   
  180.   #状态提升的基础属性(加法叠加的部分)
  181.   def state_param_plus(param_id)
  182.     states.inject(0) do |plu,sta|
  183.       plu + SkillLevel.formula(@state_level[sta.id],sta.param_add(param_id))
  184.     end
  185.   end
  186.   #状态提升的基础属性倍率(乘法叠加)
  187.   def state_param_rate(param_id)
  188.     states.inject(1.00) do |plu,sta|
  189.       plu * SkillLevel.formula(@state_level[sta.id],sta.param_rate(param_id))
  190.     end
  191.   end
  192.   #状态额外影响的属性抗性(乘法叠加)
  193.   def state_element_rate(element_id)
  194.     states.inject(1.00) do |plu,sta|
  195.       plu * SkillLevel.formula(@state_level[sta.id],sta.element_rate(element_id))
  196.     end
  197.   end
  198.   
  199.   #基础属性的计算,添加了被动技能的提升,按默认的先加后乘
  200.   def param(param_id)
  201.     value = param_base(param_id) + param_plus(param_id) +
  202.             skill_plus(param_id) + state_param_plus(param_id)
  203.     value *= param_rate(param_id) * param_buff_rate(param_id) *
  204.              skill_rate(param_id) * state_param_rate(param_id)
  205.     [[value, param_max(param_id)].min, param_min(param_id)].max.to_i
  206.   end
  207.   
  208.   #状态影响的附加属性xparam
  209.   def state_xparam(xparam_id)
  210.     states.inject(0.0) do |plu,sta|
  211.       plu + SkillLevel.formula(@state_level[sta.id],sta.xparam(xparam_id))
  212.     end
  213.   end
  214.   #附加属性xparam的计算,命中暴击什么的,迭代加算。
  215.   def xparam(xparam_id)
  216.     state_xparam(xparam_id) + @skills.inject(super(xparam_id)) do |plu,skl|
  217.       plu + SkillLevel.formula(self.skill_level(skl),$data_skills[skl].xparam(xparam_id))
  218.     end
  219.   end
  220.   
  221.   #状态影响特殊属性sparam的计算
  222.   def state_sparam(sparam_id)
  223.     states.inject(1.0) do |plu,sta|
  224.       plu * SkillLevel.formula(@state_level[sta.id],sta.sparam(sparam_id))
  225.     end
  226.   end
  227.   #特殊属性sparam的计算,经验值比率什么的,迭代连乘计算。
  228.   def sparam(sparam_id)
  229.     state_sparam(sparam_id)*skills.inject(super(sparam_id)) do |plu,skl|
  230.       plu * SkillLevel.formula(self.skill_level(skl.id),skl.sparam(sparam_id))
  231.     end
  232.   end
  233.   
  234.   #技能消耗mp由于技能等级修正的倍率,
  235.   #反正就是到SkillLevel.formula找对应编号的公式。
  236.   def skill_mp_rate(skill)
  237.     SkillLevel.formula(skill_level(skill.id),skill.mp_type)
  238.   end
  239.   
  240.   #计算最终技能消耗mp的量
  241.   def skill_mp_cost(skill)
  242.     (skill.mp_cost * mcr * skill_mp_rate(skill)).to_i
  243.   end
  244.   
  245.   #计算暴击伤害倍率super:Game_Battler中的critical_rate,返回1.5
  246.   #人物提升,职业提升,被动技能修正和装备提升
  247.   def critical_rate
  248.     v = super
  249.     v *= (1.0 + self.actor.critical_rate/100.0)
  250.     v *= (1.0 + self.class.critical_rate/100.0)
  251.     v *= skills.inject(1.00) do |plu,skl|
  252.       plu * SkillLevel.formula(self.skill_level(skl.id),skl.critical_rate)
  253.     end
  254.     v*equips.compact.inject(1.00){ |rat,equip| rat*(1.00+equip.critical_rate/100.0) }
  255.   end
  256.   
  257.   #属性伤害修正。
  258.   def element_rate(element_id)
  259.     super(element_id) * skill_element_rate(element_id) * state_element_rate(element_id)
  260.   end
  261.   
  262.   #被动技能影响的属性强化效果。
  263.   def skill_element_damage(element_id)
  264.     skills.inject(1.00) do |plu,skl|
  265.       plu * SkillLevel.formula(self.skill_level(skl.id),skl.element_damage(element_id))
  266.     end
  267.   end
  268.   
  269.   def state_element_damage(element_id)
  270.     states.inject(1.00) do |plu,sta|
  271.       plu * SkillLevel.formula(@state_level[sta.id],sta.element_damage(element_id))
  272.     end
  273.   end
  274.   
  275.   #基础属性强化,角色备注和职业备注修正。
  276.   def basic_element_damage(element_id)
  277.     (1.0 + self.actor.element_damage(element_id)/100.0) *
  278.     (1.0 + self.class.element_damage(element_id)/100.0)
  279.   end
  280.   
  281.   #计算最终属性强化基础技能装备迭代连乘
  282.   def element_damage(element_id)
  283.     basic_element_damage(element_id) *
  284.     equips.compact.inject(skill_element_damage(element_id)) do |rat,equip|
  285.       rat*(1.00+equip.element_damage(element_id)/100.0)
  286.     end
  287.   end

  288.   #受到hp伤害转移给mp的比例,遍历计算并返回最大值
  289.   def damage_convert
  290.     skl = skills.collect{|sk| sk = SkillLevel.formula(self.skill_level(sk.id),sk.damage_convert)}
  291.     sta = states.collect{|st| st = SkillLevel.formula(@state_level[st.id],st.damage_convert)}
  292.     (skl+sta).max
  293.   end
  294.   
  295.   #洗技能了,
  296.   alias item_apply_201411181846 item_apply
  297.   def item_apply(user, item)
  298.     item_apply_201411181846(user, item)
  299.     if item.is_a?(RPG::Item) and item.id == SkillLevel::RESETITEM
  300.       if self.reset_skill
  301.         self.hp = [self.hp,self.mhp].min
  302.         self.mp = [self.mp,self.mmp].min
  303.       end
  304.     end
  305.   end
  306.   
  307.   #洗技能的方法
  308.   def reset_skill
  309.     return false if self.class.auto_sp
  310.     @sp = (@level-1) * SkillLevel::LEVELUPSP + SkillLevel::INITIALSP
  311.     @skills.each  { |skill| @skill_level[skill]=0 }
  312.     return true
  313.   end
  314.   
  315. end

  316. #有关洗点水的使用判断,想和上面洗点放在一起。于是没有放进场景相关。
  317. class Scene_ItemBase < Scene_MenuBase
  318.   def item_usable?
  319.     if item.id == SkillLevel::RESETITEM
  320.       return false if item_target_actors[0].class.auto_sp
  321.       return true
  322.     end
  323.     user.usable?(item) && item_effects_valid?
  324.   end
  325. end

  326. class Game_Enemy
  327.   #敌人属性强化
  328.   def element_damage(id)
  329.     1.0 + self.enemy.element_damage(id)/100.0
  330.   end
  331.   #敌人暴击倍率 super:Game_Battler定义的critical_rate,返回1.5
  332.   def critical_rate
  333.     super * (1+self.enemy.element_damage/100.0)
  334.   end
  335.   #敌人的技能等级,要么锁定,要么1
  336.   def skill_level(skill_id)
  337.     lock = $data_skills[skill_id].lock_level if $data_skills[skill_id]
  338.     return lock if lock != 0
  339.     return 1
  340.   end
  341.     #状态提升的基础属性(加法叠加的部分)
  342.   def state_param_plus(param_id)
  343.     states.inject(0) do |plu,sta|
  344.       plu + SkillLevel.formula(@state_level[sta.id],sta.param_add(param_id))
  345.     end
  346.   end
  347.   #状态提升的基础属性倍率(乘法叠加)
  348.   def state_param_rate(param_id)
  349.     states.inject(1.00) do |plu,sta|
  350.       plu * SkillLevel.formula(@state_level[sta.id],sta.param_rate(param_id))
  351.     end
  352.   end
  353.   #状态额外影响的属性抗性(乘法叠加)
  354.   def state_element_rate(element_id)
  355.     states.inject(1.00) do |plu,sta|
  356.       plu * SkillLevel.formula(@state_level[sta.id],sta.element_rate(element_id))
  357.     end
  358.   end
  359.   
  360.   #基础属性的计算,添加了被动技能的提升,按默认的先加后乘
  361.   def param(param_id)
  362.     value = param_base(param_id) + param_plus(param_id) +
  363.             state_param_plus(param_id)
  364.     value *= param_rate(param_id) * param_buff_rate(param_id) *
  365.              state_param_rate(param_id)
  366.     [[value, param_max(param_id)].min, param_min(param_id)].max.to_i
  367.   end
  368.   
  369.   #状态影响的附加属性xparam
  370.   def state_xparam(xparam_id)
  371.     states.inject(0.0) do |plu,sta|
  372.       plu + SkillLevel.formula(@state_level[sta.id],sta.xparam(xparam_id))
  373.     end
  374.   end
  375.   #附加属性xparam的计算,命中暴击什么的,迭代加算。
  376.   def xparam(xparam_id)
  377.     state_xparam(xparam_id) + super(xparam_id)
  378.   end
  379.   
  380.   #状态影响特殊属性sparam的计算
  381.   def state_sparam(sparam_id)
  382.     states.inject(1.0) do |plu,sta|
  383.       plu * SkillLevel.formula(@state_level[sta.id],sta.sparam(sparam_id))
  384.     end
  385.   end
  386.   #特殊属性sparam的计算,经验值比率什么的,迭代连乘计算。
  387.   def sparam(sparam_id)
  388.     super(sparam_id)*state_sparam(sparam_id)
  389.   end
  390.   def state_element_damage(element_id)
  391.     states.inject(1.00) do |plu,sta|
  392.       plu * SkillLevel.formula(@state_level[sta.id],sta.element_damage(element_id))
  393.     end
  394.   end
  395.   def element_rate(element_id)
  396.     super(element_id) * state_element_rate(element_id)
  397.   end
  398. end



  399. class Game_Battler < Game_BattlerBase
  400.   
  401.   #attr_reader :state_level
  402.   #@state_level 保存状态等级的数组
  403.   alias initialize_201410131453 initialize
  404.   def initialize
  405.     initialize_201410131453
  406.     @state_level = Hash.new(0)
  407.   end
  408.   
  409.   #属性修正的计算,将使用者属性强化也计算在内的
  410.   def item_element_rate(user, item)
  411.     if item.damage.element_id < 0
  412.       user.atk_elements.empty? ? 1.0 : elements_max_rate(user)
  413.     else
  414.       element_rate(item.damage.element_id)*user.element_damage(item.damage.element_id)
  415.     end
  416.   end
  417.   
  418.   #将使用者属性强化也计算在内的最有效属性。
  419.   def elements_max_rate(user)
  420.     user.atk_elements.inject([0.0]) {|r, i| r.push(element_rate(i)*user.element_damage(i)) }.max
  421.   end
  422.   
  423.   def damage_convert #受到hp伤害转移给mp的比例
  424.     0
  425.   end
  426.   
  427.   #计算伤害,SkillLevel.formula找公式算修正。
  428.   def make_damage_value(user, item)
  429.     value = item.damage.eval(user, self, $game_variables)
  430.     if item.is_a?(RPG::Skill)
  431.       value *= SkillLevel.formula(user.skill_level(item.id),item.damage_increase_type)
  432.     end
  433.    
  434.     value *= item_element_rate(user, item)
  435.     value *= pdr if item.physical?
  436.     value *= mdr if item.magical?
  437.     value *= rec if item.damage.recover?
  438.     value = apply_critical(value,user) if @result.critical
  439.     value = apply_variance(value, item.damage.variance)
  440.     value = apply_guard(value)
  441.    
  442.     if value > 0 && damage_convert > 0
  443.       valmp = [(value*damage_convert).to_i,self.mp].min
  444.       self.mp -= valmp
  445.       value -= valmp
  446.     end
  447.     @result.make_damage(value.to_i, item)
  448.   end
  449.   
  450.   #计算暴击修正,添加了参数user
  451.   def apply_critical(value,user)
  452.     value * user.critical_rate
  453.   end
  454.   
  455.   #基础暴击修正
  456.   def critical_rate
  457.     1.9
  458.   end
  459.   
  460.   #状态附加,添加参数user,写的有点奇怪。如果有明确的user,
  461.   #就提取技能等级user.skill_level($data_states[state_id].link_skill)
  462.   #然后按SkillLevel.formula公式算得到附加概率,如果随机数比概率大(算是失败)
  463.   #就直接返回,再下去按部就班如果没有状态就附加新状态,如果有明确的user,
  464.   #状态的等级就等于之前提取的技能等级,否则为1。
  465.   def add_state(state_id,user = nil)
  466.     if state_addable?(state_id)
  467.       if user != nil
  468.         lv = user.skill_level($data_states[state_id].link_skill)
  469.       else
  470.         lv = 1
  471.       end
  472.       return if rand > SkillLevel.formula(lv,$data_states[state_id].chance)
  473.       add_new_state(state_id) unless state?(state_id)
  474.       if user != nil
  475.         @state_level[state_id] = lv
  476.       else
  477.         @state_level[state_id] = 1
  478.       end
  479.       reset_state_counts(state_id)
  480.       @result.added_states.push(state_id).uniq!
  481.     end
  482.   end
  483.   
  484.   def item_effect_add_state_attack(user, item, effect)
  485.     user.atk_states.each do |state_id|
  486.       chance = effect.value1
  487.       chance *= state_rate(state_id)
  488.       chance *= user.atk_states_rate(state_id)
  489.       chance *= luk_effect_rate(user)
  490.       if rand < chance
  491.         add_state(state_id,user)
  492.         @result.success = true
  493.       end
  494.     end
  495.   end

  496.   def item_effect_add_state_normal(user, item, effect)
  497.     chance = effect.value1
  498.     chance *= state_rate(effect.data_id) if opposite?(user)
  499.     chance *= luk_effect_rate(user)      if opposite?(user)
  500.     if rand < chance
  501.       add_state(effect.data_id,user)
  502.       @result.success = true
  503.     end
  504.   end
  505.   
  506. end
复制代码
您需要登录后才可以回帖 登录 | 注册会员

本版积分规则

Powered by Discuz! X5.0 © 2001-2026 Discuz! Team.

在本版发帖返回顶部