软控中期研究

y967

1 ,迷魂阵

中了此阵，命中率下降，有几率找不到敌人

2，幻境

在幻境中一切攻击都会虚化，也即，看见了伤害，还可能会死，但是幻觉，现实是没有任何伤害，死亡也不存在
解除时恢复到中前原样，不等于加回血和复活

3，大幻觉

幻觉自己死了，迷惑我，叫我不停加血，复活，就不会攻击了，对敌人也一样，极可怕之秘术，小心，不一定，虚实参杂

4，朗朗弄爱

看着BOSS手足无措，不知道该解毒还是复活还是加血，还是解除状态，她可能就没有中状态，十分朗朗弄爱，台湾话，很可爱

5，腹黑最高境界

之我再也预判不了你的预判，你可能真的死了，也可能真的中了幻觉，也可能没有，所以，我判断不了你的状态，可怕拉

所谓战略，没有用了，还可以用BOSS一直加血，但自己也杀不死。可怕

6，等价交换
魔鬼契约1，40%血换取一个增益效果，天使契约，30%换取敌人一个负面BUFF，如果已经有此效果，扣血照旧。

7，苟且偷生
牺牲一名队友，换取自己加满血和一个BUFF，代价是血上限下降10%

8，忍辱偷生
如果只剩自己，使用苟且偷生，则血变为1，增加一个忍辱偷生技能，每次加血20%，但伤害减半。血上限变为扣20%。

无忧谷主幻

6，纯事件也能做吧，当然可能写成代码更方便
给1号角色附加2号状态，并扣除40%hp
[pre lang="ruby"]for actor in $game_party.actors
  next if actor == nil || actor.dead?
  next unless actor.id == 1
  next if actor.state?(2)
  actor.add_state(2)
  actor.hp -= (actor.maxhp * 0.4).to_i
end[/pre]
6.1，给处于32号状态的敌人附加3号状态，之后1号角色扣除30%hp
[pre lang="ruby"]for enemy in $game_troop.enemies
  next if enemy == nil || enemy.dead?
  next unless enemy.state?(32)
  next if enemy.state?(3)
  enemy.add_state(3)
end
actor = $game_actors[1]
if actor != nil && !actor.dead?
  actor.hp -= (actor.maxhp * 0.3).to_i
end[/pre]
7，如果有数据库非1号的角色在队伍中且存活，随机选取其中一个附加1号状态，之后1号角色恢复全部hp，并附加4号状态与5号状态；若没有，什么都不做
[pre lang="ruby"]candidates = []
for actor in $game_party.actors
  next if actor == nil || actor.dead?
  next if actor.id == 1
  candidates.push(actor)
end
if candidates.size > 0
  target = candidates[rand(candidates.size)]
  target.add_state(1)
    actor1 = $game_actors[1]
  if actor1 != nil
    actor1.hp = actor1.maxhp
    actor1.add_state(4)
    actor1.add_state(5)
  end
end[/pre]
8，仅当1号角色存活，且没有其他存活同伴时，1号角色hp变成1，并附件10号状态，否则什么都不做
[pre lang="ruby"]has_other_alive = false
for actor in $game_party.actors
  next if actor == nil || actor.dead?
  if actor.id != 1
    has_other_alive = true
    break
  end
end
actor1 = $game_actors[1]
if actor1 != nil && !actor1.dead? && !has_other_alive
  actor1.hp = 1
  actor1.add_state(10)
end[/pre]
这是是按照角色编号判断，如果有多人能够学习该技能，也可以改成状态判断

加血20%，伤害减半，血上限变为扣20%，这些应该不用我教吧

灯笼菜刀王

  整天想和空气斗智斗勇,  那要有个前提, 你的敌人需要具备一定程度的行动判断能力, 否则, 你觉得默认的这种根据权重随机抽取某个行动,且不管该行动能否实行都一根筋的行动的敌人, 要怎么和你斗智斗勇, 笑

想斗智斗勇, 首先, 你要把你敌人的所有行动都设置行动条件, XP数据库提供的条件设置配合猫姐的"自导开关脚本", 可以一定程度上做到给敌人一些什么情况下不使用技能的判断, 然后,在此基础上,才能去跟他"玩花招", 笑

先不管敌人方面, 给玩家"幻觉"的方法, 一般有这几种做法 (你说的东西看不懂, 自己去参考想要的效果)

1, 信息屏蔽, 最简单的做法就是在玩家习惯了显示血条后, 突然不让你看血条了, 就会骤然觉得难度提升了, 这就是由奢入俭难, 笑


[迷糊]状态: 中了后, 自身和敌人的信息都不可见,且和自身相关的伤害显示全部为 ???


还有更阴的,  [失忆]状态, 自身所有技能和道具全部显示 ???? , 可以使用, 但是你不知道你选择的是什么, 除非, 你把技能列表的位置全部记下来  

也可以这样

把画面全挡了, 技能栏和help全看不到, 只能凭弹窗提示和音效来操作, 体验几个回合瞎猫的感觉, 笑

此外, 隐藏敌人也相当于信息遮蔽, 比如典型的战争迷雾

这是我战棋夜战, 视野外的敌人是不可见的, 光标也无法选中, 只有角色行动结束后, 在其视野内的敌人才会现身, 如果移动过程中撞上敌人,那就强行中止行动
仅仅是无法掌握敌人位置, 难度就提升了几个档次, 笑

除了遮挡, 还可以 "真.隐身"   

敌方的潜艇是看不到的,而且也不会挡路, 只有正好踩到它才会现身(或者它发动攻击)


隐身中的潜艇是无法攻击到的, 可以使用声呐让它现身,然后再让其他人攻击(潜艇现身后也是需要能反潜才可以攻击潜艇的)


或者用深弹盲丢, 看能不能中奖, 笑(只有深弹可以盲丢,其他武器都必须有目标才能攻击)
当然,如果没猜中, 那就浪费深弹和行动机会了

因为看不到敌方潜艇, 且潜艇移动不会受到敌对单位的阻拦, 所以不小心就会被潜艇偷到后方单位(我的敌人有优先攻击弱者的AI),在有潜艇出没的地图, 必须做好反潜工作, 笑

无法掌握战场信息可是比想像中的棘手呦~

2, 信息误导
比起信息遮蔽, 信息误导会更有迷惑性~

我有设计了这个职业 ,这个单位特别之处是, 作为敌方登场的时候 , 它会伪装成其他单位, 行走图,状态信息等全部伪装


上面那张是真实的面板, 而这个是战斗中查看状态面板的样子, 因为单位的属性是根据装备的武器决定的, 所以一般攻击前确认对方装备什么武器是很重要要的操作, 而这也提供了误导的可能, 笑



进入战斗后才会解除,  因为我的属性克制关系很重要, 所以信息误导很可能会造成严重损失, 越是精于计算的玩家越容易上这种当, 火影的中忍考试说过"错误的情报可能会给自己和同伴带来毁灭"

===================================
以上那些只能针对"玩家", 对电脑并不管用, 因为不管信息遮蔽还是误导, 只要你是用获取单位信息的分歧来做敌方AI, 那对电脑来说都是明牌, 除非你特意去让电脑"做出被误导的行动", 但是这样做又会让误导型战术对电脑屡试不爽, 这傻缺一踩一个准一样不好玩, 笑

像上面说的潜艇, 我方一样有潜艇单位, 但是隐身效果对电脑无效, 就算把AI设计成"隐身的时候当它不存在", 但是当电脑具有反潜手段的时候, 它必定能找到你的潜艇, 毕竟对它来说都是明牌, 摊手, 所以我除了给潜艇隐身外, 还有限制必须具备反潜能力才可以攻击到它, 这样,我方的潜艇在确保对方没有反潜能力的时候就可以快乐的偷家了, 笑

同样的,我方的伪装破袭舰也没有伪装功能, 毕竟对敌人来说没意义, 无奈摊手 , 所以我方的伪装破袭舰, 伪装体现在"逆转相克属性"上, 不过该职业的主要用途还是"偷盗", 所以也不至于因为伪装无效就失去了职业特色了

所以, 想玩"智取", 必须结合你现在能让敌人做到的程度, 去设计敌人能中招,但是又不是必定会中的"花招", 这样才好玩

像我之前说的互不攻击协议和不耗蓝协议 , 这些契约技能使用的时候是有概率会失败的(表现为目标反对,协议不成立, 笑), 不攻击协议会根据我方存活数量来增减概率, 当我方只有一个人的时候必定失败, 可不能让敌人太傻, 笑

y967

伪AI策略中期探索

1，所见即所得

一个技能，如果敌人造成伤害超过2000，则下一次攻击该技能造成伤害是敌人的这次伤害，仅下一次有效，完了重新判断。单体

扩展，高级，如果敌人伤害连续超过2000三次，则下一次攻击该技能造成伤害是敌人的三次伤害总和，仅下一次有效，完了重新判断。单体

2，富贵险中求

技能，若我方所有人血量低于30%，则该技能造成伤害2倍，若所有人血量低于10%，则为3倍。单体

3，延时标记

该技能为敌人标记，N回合后，产生爆炸伤害为该技能伤害*N，技能单体伤害为固定。

4，减速/加速标记

该技能为敌人最高速度者标记，N回合内减速/加速30%，配合3可以产生美妙效果。敌人也一样。

5，残血标记

该技能为血量低于30%/10%的单个队友标记，N回合后加血，加血效果是N*基础加血值，该技能为加血技能，如果中了前面的标记又想富贵险中求，则会产生
奇妙的不可思议的事件。

灯笼菜刀王

我说的AI可不是现在热门的"人工智能产业", 不是你用来写脚本的那东西, 笑
这里的AI是"你给敌人设置的如何行动的逻辑", 敌人能有多聪明, 全看你有多用心, 笑,  别把它当成别人的事

为了不和你脑袋里的AI混淆, 现在把 "敌人的行动逻辑" 叫 BI 好了

XP默认的敌方BI, 就是

这样设置, 这是最简单的BI, 根据权重来随机行动, 这种敌人, 根本就玩不了你心心念念的"斗智斗勇"

然后呢, 你稍微设置一下

这样, 就有了一个判断, 只有这个"可以治疗"的开关打开的时候, 它才会抽到治疗这个行动, 所以, 你可以通过调整这个开关来"控制它什么时候才能用治疗"

这就让你的BI有了些"智力"

而这个开关, 可以通过猫姐的 自更新开关 脚本, 来进一步提高"智力"

例如, 使用这个脚本后, 把2号开关的名字设置为 =a.hp < a.maxhp / 2   , 然后, 治疗这个行为调用这个2号开关, 这样, 就只有自己的HP剩一半的时候, 治疗这个行为才会参与概率抽取, 也就是说治疗这个技能只会在自己HP剩一半的时候才会有概率使用, 当然, 如果你把权重设置为10, 那就是自己HP一半的时候高概率使用治疗技能,  这样, 这个BI就聪明些喽~

同样, 也可以 设置一个开关 =a.sp > 100 这样就是自己的MP大于100的时候才会执行这个行动, 就不会傻傻的MP不够也一直用技能了

像这样,只要你给敌人的行动设置足够复杂且合理的判断, 那它的表现就比默认XP默认呆呆的概率抽取"聪明" , 这就是我说的"你想和敌人斗智斗勇, 首先要先给敌人智力",笑

我用了大概600多行的脚本做敌人BI, 让敌人可以判断"哪个目标好欺负",可以利用射程优势在目标的攻击范围外攻击, 会更换克制的武器, 会在血不足的时候吃药或者逃跑, 会据守优势地形, 会对一些非攻击目标反应(例如反潜,扫雷,维修建筑)
而这些, 都是通过大量的条件分歧来达成的, 甚至因为要判断这么多东西, 在敌人行动前还会卡一下... , 这也导致了我不敢加入阵型, 支援攻击, 光环效果利用 这些更复杂的判断, 所以上面说的那些"针对玩家的玩意"就算是平衡下了, 笑

在敌人BI上, 我可是投注了大量心血哦,  89的RPG敌人也一样, 我改造了默认的条件判断, 让其具有在相对复杂的条件下,寻找特定目标的能力


这是89敌人的行动BI,  这里的等级血量让我改造成了另外的功能, 默认的设置不一样

======================
鉴于现在要你马上会写表达式有点难度, "斗智斗勇"就作为以后的方向努力吧, 笑

如果你没用其他的行动控制脚本, 用的是XP默认的BI

那可以稍微改造下, 让敌人"聪明"一些些

全局搜索  def make_action , 然后在它下面 找到 available_actions.push(action) 这句, 在上面增加一句   next if action.kind == 1 and !self.skill_can_use?(action.skill_id)

这样, 设置的技能在无法使用的情况下(例如沉默, MP不够), 敌人就不会随机到该行动

灯笼菜刀王

BI可以认为是"行为逻辑", 默认的那种随机行动随机目标, 是没有任何逻辑可言的, 只有对方行动上有一定逻辑, 你才可以"预判", 才可以"逗", 这才有"斗智斗勇的基础" , 笑

像我的战棋是有水雷的, 水雷可以设置在地图上, 然后单位移动的时候, 经过水雷所在的格子就会引爆, 会受到伤害并强行终止行动,  是很重要的战略武器


水雷和潜艇一样, 玩家是看不到敌方设置的水雷的, 所以为了公平,敌人的BI也不会作弊去绕过水雷(当然, 扫雷舰这类的单位就会检测水雷的存在了, 笑)

而利用敌人"挑软柿子捏"的BI,也就是基本行动逻辑, 这就可以故意把弱单位暴露在敌人的攻击范围内, 引诱敌人去踩水雷


像这样, 把残血单位放在敌人的攻击范围内


然后布雷(一次布两颗是因为有被动)


结果敌人不上当... 因为吹雪虽然只有1血, 但是她11级且装备机炮, 克制敌人的鱼雷(被克制除了降低伤害,还会降低命中和暴击), 周围还有两个队友提供支援buff, 所以1级的深雪对这个敌人而言才是"软柿子" , 引诱失败.........

重来重来, 这次把吹雪改1级, 装备深弹(无法反击水面舰) ,然后1血, 把队友拉远支援不生效, 现在是100%软柿子了~~

敌人就会过来踩雷啦~

如果敌人没有"逻辑", 就无法引诱, 想让它踩雷就只能随缘了, 那就谈不上"斗智斗勇"啦,  笑

灯笼菜刀王

除了玩家和队员的好感度, 我的队员之间也是有好感度的, 在战斗中帮其恢复,或者战斗时站在一起攻击并敌人, 就会增加互相之间的好感度, 然后好感度积累到一定程度, 就可以进行"支援对话"

支援对话可以提升支援等级, 支援等级提升后, 战斗中只要相邻2格内就可以获得支援效果

每对支援有3个等级, 加上初始对话, 一共可以触发4次支援对话, 4次支援对话也相当于一段小剧情了, 笑


因为成员有400个...其CP组合少说也有一两百...做这些支援对话可是大工程,  在"情感"这一块, 我可是投入大量成本的哦

无忧谷主幻

6改：想要更多状态自己加，数组中每个状态概率均等
[pre lang="ruby"]for actor in $game_party.actors
  next if actor == nil || actor.dead?
  next unless actor.id == 1
  state_ids = [2, 5, 6]
  state_id = state_ids[rand(state_ids.size)]
  actor.add_state(state_id)
  actor.hp -= (actor.maxhp * 0.4).to_i
end[/pre]
8改：这需要用到2个变量作为记录，先用变量1记录角色第一次使用之前的最大hp，再用变量2记录使用次数
[pre lang="ruby"]has_other_alive = false
for actor in $game_party.actors
  next if actor == nil || actor.dead?
  if actor.id != 1
    has_other_alive = true
    break
  end
end
actor1 = $game_actors[1]
if actor1 != nil && !actor1.dead? && !has_other_alive
  if $game_variables[1] == 0
    $game_variables[1] = actor1.maxhp
  end
  actor1.hp = 1
  actor1.add_state(10)
  hp_lose = (actor1.maxhp * 0.2).to_i
  actor1.maxhp = [actor1.maxhp - hp_lose, 1].max
  $game_variables[2] += 1
end[/pre]
最后在战斗结束后执行这段代码即可
[pre lang="ruby"]actor = $game_actors[1]
return if actor == nil
if $game_variables[1] != 0
  actor.maxhp = $game_variables[1]
  $game_variables[1] = 0
end
if $game_variables[2] != 0
  actor.maxhp = [actor.maxhp - $game_variables[2], 1].max
  $game_variables[2] = 0
end[/pre]

无忧谷主幻

富贵险中求
Game_Battler 3反正跟伤害有关的改这段就可以了，防御修正之前
[pre lang="ruby"]         if skill.id == 57
    all_below_30 = true
    all_below_10 = true
    # 遍历己方队伍所有存活角色判断HP比例
    for actor in $game_party.actors
      next if actor.nil? || actor.dead?
      if actor.hp * 100 >= 30 * actor.maxhp
        all_below_30 = false
        all_below_10 = false
      elsif actor.hp * 100 >= 10 * actor.maxhp
        all_below_10 = false
      end
    end
    # 倍率判定：10%优先级高于30%
    if all_below_10
      self.damage = self.damage * 300 / 100
    elsif all_below_30
      self.damage = self.damage * 200 / 100
    end
  end[/pre]
测试

y967

[pre lang="ruby"]#==============================================================================
# ■ Game_Battler (分割定义 3)
#------------------------------------------------------------------------------
# 　处理战斗者的类。这个类作为 Game_Actor 类与 Game_Enemy 类的
# 超级类来使用。
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 可以使用特技的判定
  #     skill_id : 特技 ID
  #--------------------------------------------------------------------------
  def skill_can_use?(skill_id)
    # SP 不足的情况下不能使用
    if $data_skills[skill_id].sp_cost > self.sp
      return false
    end
    # 战斗不能的情况下不能使用
    if dead?
      return false
    end
    # 沉默状态的情况下、物理特技以外的特技不能使用
    if $data_skills[skill_id].atk_f == 0 and self.restriction == 1
      return false
    end
    # 获取可以使用的时机
    occasion = $data_skills[skill_id].occasion
    # 战斗中的情况下
    if $game_temp.in_battle
      # [平时] 或者是 [战斗中] 可以使用
      return (occasion == 0 or occasion == 1)
    # 不是战斗中的情况下
    else
      # [平时] 或者是 [菜单中] 可以使用
      return (occasion == 0 or occasion == 2)
    end
  end
  #--------------------------------------------------------------------------
  # ● 应用通常攻击效果
  #     attacker : 攻击者 (battler)
  #--------------------------------------------------------------------------
  def attack_effect(attacker)
    # 清除会心一击标志
    self.critical = false
    # 第一命中判定
    hit_result = (rand(100) < attacker.hit)
    # 命中的情况下
    if hit_result == true
      # 计算基本伤害
      atk = [attacker.atk - self.pdef / 2, 0].max
      self.damage = atk * (20 + attacker.str) / 20
      # 属性修正
      self.damage *= elements_correct(attacker.element_set)
      self.damage /= 100
      # 伤害符号正确的情况下
      if self.damage > 0
        # 会心一击修正
        if rand(100) < 4 * attacker.dex / self.agi
          self.damage *= 2
          self.critical = true
        end
        # 防御修正
        if self.guarding?
          self.damage /= 2
        end
      end
      # 分散
      if self.damage.abs > 0
        amp = [self.damage.abs * 15 / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      # 第二命中判定
      eva = 8 * self.agi / attacker.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 - eva
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
    end
    # 命中的情况下
    if hit_result == true
      # 状态冲击解除
      remove_states_shock
      # HP 的伤害计算
      self.hp -= self.damage
      # 状态变化
      @state_changed = false
      states_plus(attacker.plus_state_set)
      states_minus(attacker.minus_state_set)
    # Miss 的情况下
    else
      # 伤害设置为 "Miss"
      self.damage = "Miss"
      # 清除会心一击标志
      self.critical = false
    end
    # 过程结束
    return true
  end
  #--------------------------------------------------------------------------
  # ● 应用特技效果
  #     user  : 特技的使用者 (battler)
  #     skill : 特技
  #--------------------------------------------------------------------------
  def skill_effect(user, skill)
    # 清除会心一击标志
    self.critical = false
    # 特技的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
    # 或者特技的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
       ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
      # 过程结束
      return false
    end
    # 清除有效标志
    effective = false
    # 公共事件 ID 是有效的情况下,设置为有效标志
    effective |= skill.common_event_id > 0
    # 第一命中判定
    hit = skill.hit
    if skill.atk_f > 0
      hit *= user.hit / 100
    end
    hit_result = (rand(100) < hit)
    # 不确定的特技的情况下设置为有效标志
    effective |= hit < 100
    # 命中的情况下
    if hit_result == true
      # 计算威力
      power = skill.power + user.atk * skill.atk_f / 100
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # 计算倍率
      rate = 20
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
      # 计算基本伤害
      self.damage = power * rate / 20
      # 属性修正
      self.damage *= elements_correct(skill.element_set)
      self.damage /= 100
      # 伤害符号正确的情况下
      if self.damage > 0
        
        
             ----------------------------------------------------
   if skill.id == 61
    all_below_30 = true
    all_below_10 = true
    # 遍历己方队伍所有存活角色判断HP比例
    for actor in $game_party.actors
      next if actor.nil? || actor.dead?
      if actor.hp * 100 >= 30 * actor.maxhp
        all_below_30 = false
        all_below_10 = false
      elsif actor.hp * 100 >= 10 * actor.maxhp
        all_below_10 = false
      end
    end
    # 倍率判定：10%优先级高于30%
    if all_below_10
      self.damage = self.damage * 300 / 100
    elsif all_below_30
      self.damage = self.damage * 200 / 100
    end
  end
      ----------------------------------------------------
     
        
        
        
        # 防御修正
        if self.guarding?
          self.damage /= 2
        end
      end
      # 分散
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      # 第二命中判定
      eva = 8 * self.agi / user.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
      # 不确定的特技的情况下设置为有效标志
      effective |= hit < 100
    end
    # 命中的情况下
    if hit_result == true
      # 威力 0 以外的物理攻击的情况下
      if skill.power != 0 and skill.atk_f > 0
        # 状态冲击解除
        remove_states_shock
        # 设置有效标志
        effective = true
      end
      # HP 的伤害减法运算
      last_hp = self.hp
      self.hp -= self.damage
      effective |= self.hp != last_hp
      # 状态变化
      @state_changed = false
      effective |= states_plus(skill.plus_state_set)
      effective |= states_minus(skill.minus_state_set)
      # 威力为 0 的场合
      if skill.power == 0
        # 伤害设置为空的字串
        self.damage = ""
        # 状态没有变化的情况下
        unless @state_changed
          # 伤害设置为 "Miss"
          self.damage = "Miss"
        end
      end
    # Miss 的情况下
    else
      # 伤害设置为 "Miss"
      self.damage = "Miss"
    end
    # 不在战斗中的情况下
    unless $game_temp.in_battle
      # 伤害设置为 nil
      self.damage = nil
    end
    # 过程结束
    return effective
  end
  #--------------------------------------------------------------------------
  # ● 应用物品效果
  #     item : 物品
  #--------------------------------------------------------------------------
  def item_effect(item)
    # 清除会心一击标志
    self.critical = false
    # 物品的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
    # 或者物品的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
    if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
       ((item.scope == 5 or item.scope == 6) and self.hp >= 1)
      # 过程结束
      return false
    end
    # 清除有效标志
    effective = false
    # 公共事件 ID 是有效的情况下,设置为有效标志
    effective |= item.common_event_id > 0
    # 命中判定
    hit_result = (rand(100) < item.hit)
    # 不确定的特技的情况下设置为有效标志
    effective |= item.hit < 100
    # 命中的情况
    if hit_result == true
      # 计算回复量
      recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
      recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
      if recover_hp < 0
        recover_hp += self.pdef * item.pdef_f / 20
        recover_hp += self.mdef * item.mdef_f / 20
        recover_hp = [recover_hp, 0].min
      end
      # 属性修正
      recover_hp *= elements_correct(item.element_set)
      recover_hp /= 100
      recover_sp *= elements_correct(item.element_set)
      recover_sp /= 100
      # 分散
      if item.variance > 0 and recover_hp.abs > 0
        amp = [recover_hp.abs * item.variance / 100, 1].max
        recover_hp += rand(amp+1) + rand(amp+1) - amp
      end
      if item.variance > 0 and recover_sp.abs > 0
        amp = [recover_sp.abs * item.variance / 100, 1].max
        recover_sp += rand(amp+1) + rand(amp+1) - amp
      end
      # 回复量符号为负的情况下
      if recover_hp < 0
        # 防御修正
        if self.guarding?
          recover_hp /= 2
        end
      end
      # HP 回复量符号的反转、设置伤害值
      self.damage = -recover_hp
      # HP 以及 SP 的回复
      last_hp = self.hp
      last_sp = self.sp
      self.hp += recover_hp
      self.sp += recover_sp
      effective |= self.hp != last_hp
      effective |= self.sp != last_sp
      # 状态变化
      @state_changed = false
      effective |= states_plus(item.plus_state_set)
      effective |= states_minus(item.minus_state_set)
      # 能力上升值有效的情况下
      if item.parameter_type > 0 and item.parameter_points != 0
        # 能力值的分支
        case item.parameter_type
        when 1  # MaxHP
          @maxhp_plus += item.parameter_points
        when 2  # MaxSP
          @maxsp_plus += item.parameter_points
        when 3  # 力量
          @str_plus += item.parameter_points
        when 4  # 灵巧
          @dex_plus += item.parameter_points
        when 5  # 速度
          @agi_plus += item.parameter_points
        when 6  # 魔力
          @int_plus += item.parameter_points
        end
        # 设置有效标志
        effective = true
      end
      # HP 回复率与回复量为 0 的情况下
      if item.recover_hp_rate == 0 and item.recover_hp == 0
        # 设置伤害为空的字符串
        self.damage = ""
        # SP 回复率与回复量为 0、能力上升值无效的情况下
        if item.recover_sp_rate == 0 and item.recover_sp == 0 and
           (item.parameter_type == 0 or item.parameter_points == 0)
          # 状态没有变化的情况下
          unless @state_changed
            # 伤害设置为 "Miss"
            self.damage = "Miss"
          end
        end
      end
    # Miss 的情况下
    else
      # 伤害设置为 "Miss"
      self.damage = "Miss"
    end
    # 不在战斗中的情况下
    unless $game_temp.in_battle
      # 伤害设置为 nil
      self.damage = nil
    end
    # 过程结束
    return effective
  end
  #--------------------------------------------------------------------------
  # ● 应用连续伤害效果
  #--------------------------------------------------------------------------
  def slip_damage_effect
    # 设置伤害
    self.damage = self.maxhp / 10
    # 分散
    if self.damage.abs > 0
      amp = [self.damage.abs * 15 / 100, 1].max
      self.damage += rand(amp+1) + rand(amp+1) - amp
    end
    # HP 的伤害减法运算
    self.hp -= self.damage
    # 过程结束
    return true
  end
  #--------------------------------------------------------------------------
  # ● 属性修正计算
  #     element_set : 属性
  #--------------------------------------------------------------------------
  def elements_correct(element_set)
    # 无属性的情况
    if element_set == []
      # 返回 100
      return 100
    end
    # 在被赋予的属性中返回最弱的
    # ※过程 element_rate 是、本类以及继承的 Game_Actor
    #   和 Game_Enemy 类的定义
    weakest = -100
    for i in element_set
      weakest = [weakest, self.element_rate(i)].max
    end
    return weakest
  end
end
[/pre]