HP护盾脚本和自发技能脚本的冲突

jianyulei

当HP护盾存在的情况下受到攻击，同时自发技能的触发条件和伤害相关的话就会报错。自己不知道该怎么办，希望有好心人能帮我改改脚本。

[pre lang="ruby"]
#==============================================================================
# +++ 角色生命护盾 +++
#==============================================================================
# 作者 By 三途亚梦
#  -- 本脚本来自 https://rpg.blue 使用或转载请保留以上信息。
#==============================================================================
# 本脚本的作用是给玩家人物、敌人添加一个新的能力值“生命护盾”，
# 生命护盾会吸收该角色受到的来自技能造成的体力伤害。
#==============================================================================
#
# ★再次强调，生命护盾仅仅吸收来自“技能”造成的体力伤害！
#
# ★人物的生命护盾是amuhsp，
# 可以通过$game_actors[1].amuhsp之类的方式在事件中改变它的数值。
#
# ★HspClear = true 时，人物的生命护盾将在战斗结束时清零。
# 如果不想清零请将 true改为false
#
# ★HspNoAddition = true 时，
# 生命护盾的恢复将不享受恢复效果、物理及魔法伤害比率的加成，
# 但是会对 make_damage_value 的方法做出改变，会降低本脚本的兼容性。
#
# 设定部分所有文字信息的描述方法修改时请保留“”引号。
#
# ★将技能设置成体力值恢复，并在技能备注栏备注“[护盾恢复]”，
# 那么这个技能将变成增加目标角色的生命护盾值
# ★备注的时候不需要写入“”引号
#
# 角色的生命护盾没有上限，下限为0
#
# 如果需要设置一个技能为角色体力值的10%，又不想令护盾无限的加下去
# 技能公式请参照这个写法：
# b.hp * 0.1 - b.amuhsp [护盾恢复]
#
#==============================================================================
# ★ 设定部分 ★
#==============================================================================
module Amu
  module Hsp

  HspClear = true  #是否在战斗结束时清除掉玩家剩余的生命护盾

  HspNoAddition = false #是否采用本脚本的计算伤害的方法

  HspName = "生命护盾"  #生命护盾的名字

  HspABonus = "%s的%s剩余%s点！"  #玩家人物的生命护盾损伤后显示剩余值的文字

  HspEBonus = "%s的%s还剩%s点！"  #敌人的生命护盾损伤后显示剩余值的文字

  HspADamage = "%s的%s受到%s点伤害！"  #玩家人物的生命护盾受到伤害的文字

  HspEDamage = "%s的%s受到%s点伤害！"  #敌人的生命护盾受到伤害的文字

  HspARecovery  = "%s获得了一个%s点的%s保护！" #玩家的生命护盾得到提高的文字

  HspERecovery  = "%s接受了一个%s点的%s保护！" #敌人的生命护盾得到提高的文字

  HspADestory  = "%s的%s受到%s点伤害而遭到击破！" #玩家的生命护盾被击破时的文字

  HspEDestroy  = "%s的%s受到%s点伤害而被击破了！" #敌人的生命护盾被击破时的文字

  def self.play_actor_amuhspdamage  # 玩家的生命护盾受到伤害的音效
    Audio.se_play("Audio/SE/sword1.ogg", 100, 50)
  end

  def self.play_enemy_amuhspdamage   # 敌人的生命护盾受到伤害的音效
    Audio.se_play("Audio/SE/sword1.ogg", 100, 50)
  end

  def self.play_amuhsp_destory   # 生命护盾被击破时的音效
    Audio.se_play("Audio/SE/Crash.ogg", 60, 90)
  end

  end
end

class Game_ActionResult
  #--------------------------------------------------------------------------
  # ● 定义实例变量
  #--------------------------------------------------------------------------
  attr_accessor :amuhsp_damage                # 生命护盾 伤害
  #--------------------------------------------------------------------------
  # ● 清除伤害值`
  #--------------------------------------------------------------------------
  alias amu_20141125_clear_damage_values clear_damage_values
  def clear_damage_values
    amu_20141125_clear_damage_values
     @amuhsp_damage = 0
  end
  #--------------------------------------------------------------------------
  # ● 生成伤害
  #--------------------------------------------------------------------------
  alias amu_20141125_make_damage make_damage
  def make_damage(value, item)
    amu_20141125_make_damage(value, item)
    @amuhsp_damage = value if item.damage.to_hp? && @battler.amuhsp > 0 && value > 0
    @amuhsp_damage = value if item.damage.to_hp? && item.damage.recover? && item.note.include?("[护盾恢复]")
  end
  #--------------------------------------------------------------------------
  # ● 获取具有生命护盾时 HP 伤害的文字
  #--------------------------------------------------------------------------
  def hp_damage_text
    if @hp_drain > 0
      fmt = @battler.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
      sprintf(fmt, @battler.name, Vocab::hp, @hp_drain)
    elsif @hp_damage > 0
      fmt = @battler.actor? ? Vocab::ActorDamage : Vocab::EnemyDamage
      sprintf(fmt, @battler.name, @hp_damage)
    elsif @hp_damage < 0
      fmt = @battler.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
      sprintf(fmt, @battler.name, Vocab::hp, -hp_damage)
    elsif @hp_damage = 0 && @battler.amuhsp > 0
      fmt = @battler.actor? ? Amu::Hsp::HspABonus : Amu::Hsp::HspEBonus
      sprintf(fmt, @battler.name, Amu::Hsp::HspName, @battler.amuhsp)
    else
      fmt = @battler.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage
      sprintf(fmt, @battler.name)
    end
  end
  #--------------------------------------------------------------------------
  # ● 获取 生命护盾 伤害的文字
  #--------------------------------------------------------------------------
  def amuhsp_damage_text
    if @amuhsp_damage > 0 && @battler.amuhsp > 0
      fmt = @battler.actor? ? Amu::Hsp::HspADamage : Amu::Hsp::HspEDamage
      sprintf(fmt, @battler.name, Amu::Hsp::HspName, @amuhsp_damage)
    elsif @amuhsp_damage > 0 && @battler.amuhsp == 0
      fmt = @battler.actor? ? Amu::Hsp::HspADestory : Amu::Hsp::HspEDestroy
      sprintf(fmt, @battler.name, Amu::Hsp::HspName, @amuhsp_damage)
    elsif @amuhsp_damage < 0
      fmt = @battler.actor? ? Amu::Hsp::HspARecovery : Amu::Hsp::HspERecovery
      sprintf(fmt, @battler.name, -@amuhsp_damage, Amu::Hsp::HspName)
    else
      ""
    end
  end
end


class Game_BattlerBase
  attr_reader   :amuhsp                       # 生命护盾
  #--------------------------------------------------------------------------
  # ● 初始化对象
  #--------------------------------------------------------------------------
  alias amu_20141125_initialize initialize
  def initialize
    amu_20141125_initialize
    @amuhsp = 0
  end
  #--------------------------------------------------------------------------
  # ● 更改 HSP
  #--------------------------------------------------------------------------
  def amuhsp=(amuhsp)
    @amuhsp = amuhsp
    refresh
  end
  #--------------------------------------------------------------------------
  # ● 刷新
  #--------------------------------------------------------------------------
  alias amu_20141125_refresh refresh
  def refresh
    amu_20141125_refresh
    @amuhsp = [@amuhsp, 0].max
  end
end

class Game_Battler < Game_BattlerBase
  #--------------------------------------------------------------------------
  # ● 计算伤害
  #--------------------------------------------------------------------------
  if Amu::Hsp::HspNoAddition == true
    def make_damage_value(user, item)
      value = item.damage.eval(user, self, $game_variables)
      value *= item_element_rate(user, item)
      value *= pdr if item.physical? && !make_amuhsp?(item)
      value *= mdr if item.magical? && !make_amuhsp?(item)
      value *= rec if item.damage.recover? && !make_amuhsp?(item)
      value = apply_critical(value) if @result.critical
      value = apply_variance(value, item.damage.variance)
      value = apply_guard(value)
      if make_amuhsp?(item)
        def actor_amuhsp?
          return true
        end
      end
      @result.make_damage(value.to_i, item)
    end
  else
    alias amu_20141125_make_damage_value make_damage_value
    def make_damage_value(user, item)
      amu_20141125_make_damage_value(user, item)
      if make_amuhsp?(item)
        def actor_amuhsp?
          return true
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 处理伤害
  #    调用前需要设置好
  #    @result.hp_damage   @result.mp_damage
  #    @result.hp_drain    @result.mp_drain
  #--------------------------------------------------------------------------
  def execute_damage(user)
    on_damage(@result.hp_damage) if @result.hp_damage > 0
    if self.amuhsp > 0 && @result.hp_damage > 0
      eamuhsp = self.amuhsp
      self.amuhsp -= @result.hp_damage
      self.amuhsp <= 0 ? @result.hp_damage -= eamuhsp : @result.hp_damage = 0
    end
    if actor_amuhsp?
      self.amuhsp -= @result.hp_damage
      @result.hp_damage = 0
      def actor_amuhsp?
        return false
      end
    else
      self.hp -= @result.hp_damage
    end
    self.mp -= @result.mp_damage
    user.hp += @result.hp_drain
    user.mp += @result.mp_drain
  end
  #--------------------------------------------------------------------------
  # ● 判断技能是否用来增加生命护盾
  #--------------------------------------------------------------------------
  def make_amuhsp?(item)
    return false unless item.is_a?(RPG::Skill)
    return item.note.include?("[护盾恢复]")
  end
  def actor_amuhsp?
    return false
  end
  #--------------------------------------------------------------------------
  # ● 清除 生命护盾
  #--------------------------------------------------------------------------
  def clear_amuhsp
    self.amuhsp = 0
  end
  #--------------------------------------------------------------------------
  # ● 战斗结束处理
  #--------------------------------------------------------------------------
  alias amu_20141125_on_battle_end on_battle_end
  def on_battle_end
    amu_20141125_on_battle_end
    clear_amuhsp if Amu::Hsp::HspClear == true
  end
end

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 设置具有生命护盾时玩家被击的效果
  #--------------------------------------------------------------------------
  def perform_hspdamage_effect
    $game_troop.screen.start_shake(5, 5, 10)
    @sprite_effect_type = :blink
    Amu::Hsp.play_actor_amuhspdamage
  end
end

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● 设置具有生命护盾时敌人被击的效果
  #--------------------------------------------------------------------------
  def perform_hspdamage_effect
    $game_troop.screen.start_shake(5, 5, 10)
    @sprite_effect_type = :blink
    Amu::Hsp.play_enemy_amuhspdamage
  end
end

class Window_BattleLog < Window_Selectable
  #--------------------------------------------------------------------------
  # ● 显示伤害
  #--------------------------------------------------------------------------
  def display_damage(target, item)
    if target.result.missed
      display_miss(target, item)
    elsif target.result.evaded
      display_evasion(target, item)
    else
      display_amuhsp_damage(target, item)
      display_hp_damage(target, item)
      display_mp_damage(target, item)
      display_tp_damage(target, item)
    end
  end
  #--------------------------------------------------------------------------
  # ● 显示 生命护盾 伤害
  #--------------------------------------------------------------------------
  def display_amuhsp_damage(target, item)
    return if target.dead? || target.result.amuhsp_damage == 0
    if target.result.amuhsp_damage > 0 && target.amuhsp > 0 && target.result.hp_drain == 0
      target.perform_hspdamage_effect
    end
    Amu::Hsp.play_amuhsp_destory if target.result.amuhsp_damage > 0 && target.amuhsp == 0
    Sound.play_recovery if target.result.amuhsp_damage < 0
    add_text(target.result.amuhsp_damage_text)
    wait
  end
end[/pre]

[pre lang="ruby"]
module AutoSkill; Ask, Msk = {}, {}


Ask[50] = {'范围' => 'user','条件' => 'state?(58) && !user.actor? && item.physical? && dmg(:hp) > $game_actors[2].hp*0.08 && $game_actors[2].level >=4','几率' => '100','时机' => '受伤后'}



#------------------------------------------------------------------------------
end # Do not remove

#==============================================================================
#
# 自发技能 by Silentever(夜光云)
#    (自动发动技能)
#
#    2015-10-28 更新：修复BUG，最终版
#    2015-10-09 更新：修复BUG，写法优化，追加无视行动限制的自发技能，追加简化定义
#                     删除：自发技能使用成功分歧判定
#    2015-09-19 更新：追加：last_act定义，自发技能使用成功分歧判定
#    2015-09-12 更新：修复BUG，支持让敌人也使用自发技能，追加地图自发技能，追加对象选择机制
#    2015-08-17 发布
#
#==============================================================================
# ▼ 设定
#    填入【 Ask[ID] = { '参数名' => '算法' (用','分开) } 】
#
#  ID.......技能ID。对指定的技能无任何要求(可以发动任何技能)。
#
#  参数列表：
#    几率...发动几率(0~100)，不填写时为默认100。
#           只要是返回数字，可以用变量计算；超出范围不会出错请安心。
#    条件...发动先置条件(返回true/false)，不填写时为默认true(无先置条件)。
#    时机...限定发动的时机，详细在下面1。
#    范围...设置方法请看下面2。
#    强制...设定为true的场合，技能将会无视此脚本设置的条件与学会条件以外的，
#           任何技能的常规发动条件(MP不足，行动不能等)。
#
#  例子：
#    Ask[1] = {}                         => 使用1号技能(没有任何参数用空'{}')
#    Ask[2] = { '几率' => '50' }         => 50%几率使用2号技能
#    Ask[3] = { '条件' => 'luk > 50' }   => 幸运高于50(不包括等于)使用3号技能
#    Ask[4] = { '条件' => 'state?(2)',
#               '几率' => '100 - @state_turns[2] * 10'}
#        => 持有2号状态的情况下，以(100-2号状态剩余回合数*10)的几率发动
#
#  填写时请把所有的参数跟其内容用 '' 或 "" 号包封。
#  【注意】使用自发技能的第一个先置条件是学会(不论升级或特性添加)，
#  有必要让想让使用该技能的角色学会；另外敌人必须使用特性添加技能才能使用
#  技能的使用会受到基础使用条件的限制(MP不足，使用场合不符，角色无法行动等)。
#   
#  补充：
#  1) 重复添加相同的ID技能，【没办法】重复使用，写在后面的内容会覆盖先前的内容。
#  2) 同一个时机中有复数自发技能行动角色时，会根据行动速度进行排列。
#  3) 只能在战斗中使用，关于地图技能请看下面。
#  4) 填写时注意使用全部半角的标点符号。
#
#
#  ■【时机】(2015-10-09 更新中自发技能从发动时机分离)
#  在参数中加入【 '时机' => '战斗开始, 战斗结束' 】
#  可以把自发技能的使用锁定在后面填入的时机中。以上例子是把时机限定在了战斗开始跟结束。
#  因为不填写时会每个时机都使用一次，因此【强烈】建议填写。
#
#  时机与以往不变：
#    战斗开始，战斗结束  => 敌人出现时，胜利或逃跑后
#    回合开始，回合结束  => 全部选择好行动后，回合正式开始的时候，以及回合结束
#    行动前，行动后      => 自己进行主要行动(使用技能/道具)的前后
#    受伤前，受伤后      => 自己成为技能/道具的对象，效果处理前/后
#  直接把以上部分直接输入，用 , 分开。
#
#
#  ■【范围】
#  因为这部分比较复杂，慎入。注意在最后全部都用 '' 或 "" 号包封。
#  不填写时，会自动选择对象(遵守原使用范围)。
#  设置对象群体时，将会无视技能本身的使用范围。
#
#  设置时，可以放3部分，用“,”互相分开。其中1号是必须放在最前，其余可以随意排序。
#  1) 范围的对象群体。用“+”追加，“-”排除。此外必须在每个运算符号前后留个空格。
#     self是使用者自己。last是最后一个对象。重复加入会复数处理效果。
#     最后一个对象指最后一次输入指令时选择的对象索引(每个角色独立)。
#  2) 定成“max或min : 比较数值 : 采取数量”，不填写数量时当作1处理。
#     会从范围中选择该数量的，持有最高/最低指定数值的单位。
#  3) 用代码进行计算返回true/false，从范围选择所有符合条件的单位。
#     计算代码可以使用跟伤害公式一样的变量：a=使用者，b=单独对象，v=游戏变量。
#     不存在可选对象时，技能不发动。
#
#  例子：
#  Ask[5] = { '范围' => 'self + last' }
#      => 将目标对象锁定成自身与自身的最后对象
#  Ask[6] = { '范围' => 'party - self, max:hp:2' }
#      => 在玩家队伍成员中，除使用者以外，选择HP最高的2个角色
#  Ask[7] = { '范围' => 'troop, b.state?(10)' }
#      => 从敌群中选择所有持有10号状态的成员
#  Ask[8] = { '范围' => 'allies, b.state?(1), max:mhp' }
#      => 从持有1号状态的同伴中选择HP上限最高的1个成员(敌人使用会选择敌人)
#  Ask[9] = { '范围' => 'party + self, min:hp:3, b.hp > 0' }
#      => 从HP高于0的玩家队伍以及自身中选取3个HP最低的成员。
#         注意角色使用的场合会把自身计算2此，因此会占有2个对象，并受到2次技能效果。
#
#
#  ■【仅限伤害处理】
#  仅在伤害处理可以使用user与item。
#  User...攻击使用者的单位(敌人)。在对象组中填入“user”可以指定该单位做对象。
#  Item...攻击单位所使用的技能。
#  此外，受到伤害之后还能调用“dmg(:hp)”等变量获得伤害量，
#
#  例子2：
#  Ask[10] = { '时机' => '受伤前',
#              '范围' => 'user' }
#      => 对攻击单位使用技能10号反击。
#  Ask[11] = { '时机' => '受伤后',
#              '条件' => 'dmg(:hp) >= 20' }
#      => 受到20HP以上的伤害时发动(限伤害后)。
#
#  其他方法(限定在受伤后使用)：
#    dmg( )    => 获取伤害量，括号中填入种类“:hp”,“:mp”或“:tp”
#    drn( )    => 获取吸收量，括号中填入“:hp”或“:mp”
#    missed?   => 是否击中(输出true/false)
#    evaded?   => 是否被回避(输出true/false)
#    critical? => 是否暴击成功(输出true/false)
#
#
#  ■【追加定义：party/troop/allies/oppons】
#  为了方便输入简化了队伍与敌群的变量名。
#
#  party    => 获取玩家队伍(数组)
#  party(1) => 获取队伍中首位的角色(角色)
#  troop    => 获取全体敌群(数组)
#  troop(1) => 获取1号敌人(敌人)
#
#  allies    => 获取使用者的同伴，角色的场合玩家队伍，敌人的场合敌群
#  allies(1) => 获取同伴1号
#  oppons    => 获取使用者的对手，角色的场合敌群，敌人的场合玩家队伍
#  oppons(1) => 获取对手1号
#
#
#  ■【追加定义：last_act】
#  获取玩家输入的行动指令，玩家在游戏中输入攻击行动，可以通过此方法获取。
#  注意获取的是行动而不是技能(道具的使用也是行动)。
#  只有重新输入行动后才会更新，因此会保留到下次战斗。
#  因为这个行动不会被执行所以没有修改的意义。
#  具体参考Game_Action。
#
#  方法预览：
#  last_act.attack?     => 是否普通攻击(true/false)
#  last_act.guard?      => 是否防御(true/false)
#
#  last_act.skill?      => 是否技能(true/false)
#  last_act.skill?(id)  => 是否为id号技能(true/false)
#
#  last_act.item?       => 是否道具(true/false)
#  last_act.item?(id)   => 是否为id号道具(true/false)
#
#  last_act.valid?      => 判断角色是否可以执行该行动(true/false)
#  last_act.item        => 获取行动的技能或使用道具(对象物品)
#
#------------------------------------------------------------------------------
#
# ▼ 地图发动的自发技能
#    使用【 Msk[ID] = { '参数名' => '算法' (用','分开) } 】
#    注意参数与战斗用的设置不一定相同。
#
#  频率...发动频率，玩家每行走此数值的步数使用1次。不填入不会发动。
#         默认系统中20步会算作1回合(参考用)。
#  条件...同战斗设置。
#  范围...同战斗设置。注意在地图上不存在$game_troop。
#  显示...是否显示使用消息，填入true会弹出对话框，否则无任何提示。
#
#==============================================================================



#==============================================================================
# ▼ 脚本内容：不可编辑
#==============================================================================
class Game_Battler < Game_BattlerBase
  #--------------------------------------------------------------------------
  include AutoSkill
  Ask.each_value {|s| s.default = ''}
  Msk.each_value {|s| s.default = ''}
  
  # NewMethods: 追加简易定义
  def party(n = nil)
    return $game_party.members unless n
    return $game_party.members[n] end
  def troop(n = nil)
    return $game_troop.members unless n
    return $game_troop.members[n] end
  def allies(n = nil)
    return party(n) if actor?
    return troop(n) if enemy?; end
  def oppons(n = nil)
    return party(n) if enemy?
    return troop(n) if actor?; end
   
  def dmg(type = :hp); eval "@result_log.#{type.to_s}_damage" end
  def drn(type = :hp); eval "@result_log.#{type.to_s}_drain" end
  def missed?;   @result_log.missed end
  def evaded?;   @result_log.evaded end
  def critical?; @result_log.critical end
   
  def user; @attack_user end
  def item; @attack_item end
  def last
    return allies(last_act.target_index) if last_act.item.for_friend?
    return oppons(last_act.target_index) if last_act.item.for_opponent?
  end
  
  # NewMethod: 最后一个主要行动
  def last_act; @last_act; end
  def set_last_action
    @last_act = current_action if !current_action.is_a? Game_AutoAction
  end
  # AliasMethod: 记录战斗结果
  attr_reader :result_log
  def set_result_log
    @result_log = @result.clone end
  # AliasMethod: 初始化
  alias :initialize_ask :initialize
  def initialize; initialize_ask
    @last_act = Game_Action.new(self)
    @result_log = Game_ActionResult.new(self) end
  
  # NewMethod: 自发技能处理
  def proc_auto_skill(timing = nil, user = nil, item = nil)
    return unless SceneManager.scene_is?(Scene_Battle)
    @attack_user, @attack_item = user, item
    Ask.each {|i, v| skill = $data_skills
      next unless skills.include?(skill)
      set_auto_skill(i, v, timing)}
  end
  
  # NewMethod: 自发技能设置
  def set_auto_skill(i, v, t)
    return unless v['时机'].empty? or v['时机'].split(',').map{|s|s.strip}.include?(t)
    return unless v['几率'].empty? or eval(v['几率']).to_i > rand(100)
    return unless v['条件'].empty? or eval(v['条件'])
    action = Game_AutoAction.new(self, eval(v['强制']), i)
    unless make_auto_targets(action, v['范围']).empty?
      @actions.insert(0, action)
      BattleManager.autoskill_users.push(self)
  end end
  
  # NewMethod: 设置行动对象
  def make_auto_targets(action, scope)
    if !scope.empty?; scope = scope.split(',')
      unit = []; scope.shift.split(' ').each_with_index{|s, i|
        @oper = '+' unless @oper; if i % 2 == 1; @oper = s; next end
        unit.push(eval(s)) if @oper['+']
        unit.reject!{|bat| [eval(s)].flatten.include?(bat)} if @oper['-']
        unit.flatten!}; remove_instance_variable :@oper
      if requir = scope.reject{|s| s[/max|min/]}[0]; unit.select!{|member|
        a, b, v = self, member, $game_variables; eval requir}; end
      if prior = scope.find{|s| s[/max|min/]}; prior = prior.split(':').map{|s|s.strip}
        unit = unit.sort_by(&prior[1].to_sym); n = eval(prior[2]) rescue n = 1
        unit = unit.first(n) if prior[0]['min']
        unit = unit.last(n)  if prior[0]['max']
      end end
    return action.auto_targets = unit if unit
    return action.auto_targets = [:rand]
  end
  
  # NewMethod: 地图技能
  def proc_map_skill
    return unless SceneManager.scene_is?(Scene_Map)
    Msk.each {|i, v| skill = $data_skills
      h = {}; v.each {|i, v| h = v.split(',').map{|s| s.strip}}
      next unless skills.include?(skill)
      next unless usable?(skill)
      next unless h['步数'].empty? or $game_party.steps % eval(h['步数']) == 0
      next unless h['条件'].empty? or eval(h['条件'])
      pay_skill_cost(skill)
      item.effects.each {|effect| item_global_effect_apply(effect)} if
        eval(h['消息'])
      make_auto_targets(action, h['范围']).each {|target|
        skill.repeats.times {target.item_apply(self, skill)}}}
  end
  #--------------------------------------------------------------------------
end
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # AliasMethod: 地图画面上回合结束的处理
  alias :turn_end_on_map_ask :turn_end_on_map
  def turn_end_on_map; turn_end_on_map_ask
    proc_map_skill end
  #--------------------------------------------------------------------------
end
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # NewMethod: 获取技能实例的数组
  def skills
    added_skills.sort.collect {|id| $data_skills[id] }
  end
  #--------------------------------------------------------------------------
end
#==============================================================================
class Game_Action
  #--------------------------------------------------------------------------
  # 判断用定义
  def guard?; item == $data_skills[subject.guard_skill_id] end
  def skill?(id = 0)
    return item == $data_skills[id] if id > 0
    return item.is_a?(RPG::Skill) end
  def item?(id = 0)
    return item == $data_items[id] if id > 0
    return item.is_a?(RPG::Item) end
  #--------------------------------------------------------------------------
end
#==============================================================================
class Game_AutoAction < Game_Action
  #--------------------------------------------------------------------------
  attr_accessor :auto_action
  attr_accessor :auto_targets
  
  # 初始化对象
  def initialize(subject, forcing, skill_id)
    super(subject, forcing)
    set_skill(skill_id) end
   
  # 清除
  def clear; super
    @auto_action = false
    @auto_targets = [] end

  # 生成目标数组
  def make_targets
    return super if @auto_targets.include?(:rand)
    return @auto_targets end
   
  # 目标为队友
  def targets_for_friends
    @target_index = rand(subject.friends_unit.members.size) if
      @auto_targets.include?(:rand)
    super end
  #--------------------------------------------------------------------------
end
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # AliasMethod: 更新画面
  alias :update_ask :update
  def update; update_ask
    BattleManager.terminate unless process_autoskill
  end
  
  # AliasMethod: 开始队伍指令的选择
  alias :start_party_command_selection_ask :start_party_command_selection
  def start_party_command_selection
    return if BattleManager.judge_win_loss
    start_party_command_selection_ask
  end
  
  # AliasMethod: 回合开始
  alias :turn_start_ask :turn_start
  def turn_start; turn_start_ask
    all_battle_members.each {|battler| battler.set_last_action}
    check_auto_skills(all_battle_members, '回合开始')
  end
  
  # AliasMethod: 回合结束
  alias :turn_end_ask :turn_end
  def turn_end
    check_auto_skills(all_battle_members, '回合结束')
    turn_end_ask end
  
  # OverWrite: 处理战斗行动
  def process_action
    return if scene_changing?
    if !@subject || !@subject.current_action
      @subject = BattleManager.next_subject end
    return turn_end unless @subject
    return unless @subject
    check_auto_skills([@subject], '行动前')
    process_action_b
    process_action_end unless @subject.current_action
    check_auto_skills([@subject], '行动后')
  end
   
  # NewMethod: 处理战斗行动
  def process_action_b
    if @subject.current_action
      @subject.current_action.prepare
      if @subject.current_action.valid?
        @status_window.open
        execute_action
      end
      @subject.remove_current_action
    end
  end
  
  # NewMethod: 处理自动技能
  def process_autoskill
    return false if BattleManager.autoskill_users.empty?
    @log_window.wait
    last_subject = @subject if @subject
    @subject = BattleManager.autoskill_users.shift
    @using_auto_skill = true
    process_action_b
    @subject = last_subject if last_subject
    @using_auto_skill = false
    return true
  end
  
  # AliasMethod: 使用技能／物品
  alias :use_item_ask :use_item
  def use_item
    if @using_auto_skill
      use_item_ask
    else; use_item_no_autoskill end
  end
   
  # NewMethod: 使用非自发技能／物品
  def use_item_no_autoskill
    item = @subject.current_action.item
    @log_window.display_use_item(@subject, item)
    @subject.use_item(item)
    refresh_status
    targets = @subject.current_action.make_targets.compact
    show_animation(targets, item.animation_id)
    check_auto_skills(targets, '受伤前', @subject, item)
    targets.each {|target| item.repeats.times { invoke_item(target, item) } }
    check_auto_skills(targets, '受伤后', @subject, item)
  end
  
  # AliasMethod: 应用技能／物品效果
  alias :apply_item_effects_ask :apply_item_effects
  def apply_item_effects(target, item)
    apply_item_effects_ask(target, item)
    target.set_result_log
  end
  
  # NewMethod: 使用自发技能
  def check_auto_skills(subjects = [], *args)
    subjects.each {|subject| subject.proc_auto_skill(*args) if subject}
    while process_autoskill
  end end
  #--------------------------------------------------------------------------
end
#==============================================================================
module BattleManager
  #--------------------------------------------------------------------------
  class << self
    alias :battle_start_ask :battle_start
    alias :on_encounter_ask :on_encounter; end
   
  # AliasMethod: 战斗开始
  def self.battle_start
    @battle_result = nil
    battle_start_ask
    SceneManager.scene.check_auto_skills($game_party.members+$game_troop.members, '战斗开始')
    on_encounter_ask
    if @preemptive
      $game_message.add(sprintf(Vocab::Preemptive, $game_party.name))
    elsif @surprise
      $game_message.add(sprintf(Vocab::Surprise, $game_party.name))
    end
    wait_for_message
  end
  
  # AliasMethod: 遇敌时的处理
  def self.on_encounter; end
  
  # OverWrite: 胜利时的处理
  def self.process_victory
    play_battle_end_me
    replay_bgm_and_bgs
    $game_message.add(sprintf(Vocab::Victory, $game_party.name))
    display_exp
    gain_gold
    gain_drop_items
    gain_exp
    battle_end(0)
    return true
  end
  
  # OverWrite: 中止时的处理
  def self.process_abort
    replay_bgm_and_bgs
    battle_end(1)
    return true
  end
  
  # OverWrite: 全灭时的处理
  def self.process_defeat
    $game_message.add(sprintf(Vocab::Defeat, $game_party.name))
    wait_for_message
    replay_bgm_and_bgs if @can_lose
    battle_end(2)
    return true
  end
  
  # OverWrite: 战斗结束 > 结果（0:胜利 1:撤退 2:全灭）
  def self.battle_end(result)
    @phase = nil
    @battle_result = result
    $game_party.on_battle_end
    $game_troop.on_battle_end
    SceneManager.scene.check_auto_skills($game_party.members, '战斗结束')
  end
  
  # NewMethod: 退出管理器
  def self.terminate
    return unless @battle_result
    revive_battle_members if @battle_result == 2 && @can_lose
    @event_proc.call(@battle_result) if @event_proc
    SceneManager.return
    SceneManager.goto(Scene_Gameover) if @battle_result == 2 && !@can_lose
    SceneManager.exit if $BTEST
  end
  
  # NewMethod: 自发技能行动列表
  def self.autoskill_users
    @autoskill_users ||= []
    @autoskill_users.each {|battler| battler.make_speed }
    @autoskill_users.sort! {|a,b| b.speed - a.speed }
    return @autoskill_users
  end
  #--------------------------------------------------------------------------
end
#==============================================================================
# ▼ END
#==============================================================================[/pre]