敌人攻击我方角色，这场战斗我方角色攻击力下降

mkl7788

我自己试过，可以实现，不过有问题，
A角色atk= 10，被敌人攻击，A角色atk= 8，
战斗结束了  查看状态 ，A角色atk = 8，怎么变回战斗之前的攻击力

战斗的时候，我方被攻击的角色 攻击力减少1点，
战斗结束   ，攻击力变少的角色，回归战斗之前的那样 。

Six_Fish

每次战斗前先把攻击力代入变量存起来？

chd114

你是直接动了属性了吧···
做成状态就可以了，持续99999回合脱离战斗就解除的那种

mkl7788

chd114 发表于 2020-6-6 21:43
你是直接动了属性了吧···
做成状态就可以了，持续99999回合脱离战斗就解除的那种 ...

状态 我试过不行，
比如 角色攻击力是10
第一回合 被敌人攻击  附加了状态攻击力是90%，  现在攻击力变成了 9
第二回合 再被敌人攻击  附加了状态攻击力是90%， 仍然是9的攻击，变不了8攻击力
状态不叠加的

小姐姐一个

mkl7788 发表于 2020-6-6 22:37
状态 我试过不行，
比如 角色攻击力是10
第一回合 被敌人攻击  附加了状态攻击力是90%，  现在攻击力变成 ...

搜索 状态叠加 没有的话向大佬砸钱qwq？

zyzzyzzyzzyz

如二楼 在战斗之前把攻击力存到变量里，然后战斗结束以后再改按数值回去？
或者做一个状态，每次被触发减攻击力1点，然后某变量+1，并消除该状态，最后在战斗结束后把攻击力再加上那个变量的数值？
（均未实测）

Cupidk爱呗茶

感觉这个问题很有意思就稍微研究了一下 写的比较仓促。。有什么问题就请联系层主吧
思路大概是战斗的伤害处理不在直接使用角色攻击力 新建一个战斗中的攻击力代替他 被特殊敌人攻击后降低的也是这个属性自然不会影响到真实的角色攻击  
试试看能不能满足需求

RUBY 代码复制

# 使用方法: 插入脚本页Main前
module SET_NEW
  # 这里设置敌方每次攻击会降低多少角色攻击力
  Reduce_atk = 100
  # 指定攻击会降低角色攻击力的敌方ID 
  # 例 ：[1,2,3] 即为数据库中 1，2，3号敌人
  # 或者 Enemy_Reduct = 1..20 即代表1号到20号敌人攻击命中时会降低我方攻击力
  Enemy_Reduct = [1,2,3]  
end  
# 设置结束。。下面为实现思路  ########
class Game_Battler
  attr_writer :atk_battler # 战斗中的攻击力
  alias :new_2020607_initialize :initialize
  def initialize
    new_2020607_initialize
    @atk_battler = 0
  end
  # 读取战斗中的攻击力属性
  def atk_battler
    atk = @atk_battler
    @states.each do |i|
     atk *= $data_states[i].atk_rate / 100.0
    end
    return Integer(atk)
  end  
  # 初始化战斗中攻击力
  def atk_battler_init
    @atk_battler = self.base_atk
  end  
  # 修改攻击公式
  def attack_effect(attacker)
    # 清除会心一击标志
    self.critical = false
    # 第一命中判定
    hit_result = (rand(100) < attacker.hit)
    # 命中的情况下
    if hit_result == true
      # 计算基本伤害
      atk = [attacker.atk_battler - 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
      # 战斗中角色被攻击时降低攻击力 ######
      if self.is_a?(Game_Actor) && SET_NEW::Enemy_Reduct.any?{|id| id === attacker.id} 
       self.atk_battler -= SET_NEW::Reduce_atk 
      end 
      # 状态变化
      @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
 
  # 修改特技公式
  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_battler * 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 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
end  
# 初始化战斗中的攻击力数值
class Scene_Battle
  #--------------------------------------------------------------------------
  # ● 主处理
  #--------------------------------------------------------------------------
  def main
    # 初始化战斗用的各种暂时数据
    $game_temp.in_battle = true
    $game_temp.battle_turn = 0
    $game_temp.battle_event_flags.clear
    $game_temp.battle_abort = false
    $game_temp.battle_main_phase = false
    $game_temp.battleback_name = $game_map.battleback_name
    $game_temp.forcing_battler = nil
    # 初始化战斗用事件解释器
    $game_system.battle_interpreter.setup(nil, 0)
    # 准备队伍
    @troop_id = $game_temp.battle_troop_id
    $game_troop.setup(@troop_id)
    # 生成角色命令窗口
    s1 = $data_system.words.attack
    s2 = $data_system.words.skill
    s3 = $data_system.words.guard
    s4 = $data_system.words.item
    @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])
    @actor_command_window.y = 160
    @actor_command_window.back_opacity = 160
    @actor_command_window.active = false
    @actor_command_window.visible = false
    # 生成其它窗口
    @party_command_window = Window_PartyCommand.new
    @help_window = Window_Help.new
    @help_window.back_opacity = 160
    @help_window.visible = false
    @status_window = Window_BattleStatus.new
    @message_window = Window_Message.new
    # 生成活动块
    @spriteset = Spriteset_Battle.new
   # 此处为修改
    # 初始化我方攻击力 ######
    $game_party.actors.each {|actor| actor.atk_battler_init}
    # 初始化敌方攻击力 ######
    $game_troop.enemies.each {|enemy| enemy.atk_battler_init}
    # 初始化等待计数
    @wait_count = 0
    # 执行过渡
    if $data_system.battle_transition == ""
      Graphics.transition(20)
    else
      Graphics.transition(40, "Graphics/Transitions/" +
        $data_system.battle_transition)
    end
    # 开始自由战斗回合
    start_phase1
    # 主循环
    loop do
      # 刷新游戏画面
      Graphics.update
      # 刷新输入信息
      Input.update
      # 刷新画面
      update
      # 如果画面切换的话就中断循环
      if $scene != self
        break
      end
    end
    # 刷新地图
    $game_map.refresh
    # 准备过渡
    Graphics.freeze
    # 释放窗口
    @actor_command_window.dispose
    @party_command_window.dispose
    @help_window.dispose
    @status_window.dispose
    @message_window.dispose
    if @skill_window != nil
      @skill_window.dispose
    end
    if @item_window != nil
      @item_window.dispose
    end
    if @result_window != nil
      @result_window.dispose
    end
    # 释放活动块
    @spriteset.dispose
    # 标题画面切换中的情况
    if $scene.is_a?(Scene_Title)
      # 淡入淡出画面
      Graphics.transition
      Graphics.freeze
    end
    # 战斗测试或者游戏结束以外的画面切换中的情况
    if $BTEST and not $scene.is_a?(Scene_Gameover)
      $scene = nil
    end
  end
end

# 使用方法: 插入脚本页Main前


module SET_NEW


  # 这里设置敌方每次攻击会降低多少角色攻击力


  Reduce_atk = 100


  # 指定攻击会降低角色攻击力的敌方ID 


  # 例 ：[1,2,3] 即为数据库中 1，2，3号敌人


  # 或者 Enemy_Reduct = 1..20 即代表1号到20号敌人攻击命中时会降低我方攻击力


  Enemy_Reduct = [1,2,3]  


end  


# 设置结束。。下面为实现思路  ########


class Game_Battler


  attr_writer :atk_battler # 战斗中的攻击力


  alias :new_2020607_initialize :initialize


  def initialize


    new_2020607_initialize


    @atk_battler = 0


  end


  # 读取战斗中的攻击力属性


  def atk_battler


    atk = @atk_battler


    @states.each do |i|


     atk *= $data_states[i].atk_rate / 100.0


    end


    return Integer(atk)


  end  


  # 初始化战斗中攻击力


  def atk_battler_init


    @atk_battler = self.base_atk


  end  


  # 修改攻击公式


  def attack_effect(attacker)


    # 清除会心一击标志


    self.critical = false


    # 第一命中判定


    hit_result = (rand(100) < attacker.hit)


    # 命中的情况下


    if hit_result == true


      # 计算基本伤害


      atk = [attacker.atk_battler - 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


      # 战斗中角色被攻击时降低攻击力 ######


      if self.is_a?(Game_Actor) && SET_NEW::Enemy_Reduct.any?{|id| id === attacker.id} 


       self.atk_battler -= SET_NEW::Reduce_atk 


      end 


      # 状态变化


      @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


 


  # 修改特技公式


  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_battler * 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 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


end  


# 初始化战斗中的攻击力数值


class Scene_Battle


  #--------------------------------------------------------------------------


  # ● 主处理


  #--------------------------------------------------------------------------


  def main


    # 初始化战斗用的各种暂时数据


    $game_temp.in_battle = true


    $game_temp.battle_turn = 0


    $game_temp.battle_event_flags.clear


    $game_temp.battle_abort = false


    $game_temp.battle_main_phase = false


    $game_temp.battleback_name = $game_map.battleback_name


    $game_temp.forcing_battler = nil


    # 初始化战斗用事件解释器


    $game_system.battle_interpreter.setup(nil, 0)


    # 准备队伍


    @troop_id = $game_temp.battle_troop_id


    $game_troop.setup(@troop_id)


    # 生成角色命令窗口


    s1 = $data_system.words.attack


    s2 = $data_system.words.skill


    s3 = $data_system.words.guard


    s4 = $data_system.words.item


    @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])


    @actor_command_window.y = 160


    @actor_command_window.back_opacity = 160


    @actor_command_window.active = false


    @actor_command_window.visible = false


    # 生成其它窗口


    @party_command_window = Window_PartyCommand.new


    @help_window = Window_Help.new


    @help_window.back_opacity = 160


    @help_window.visible = false


    @status_window = Window_BattleStatus.new


    @message_window = Window_Message.new


    # 生成活动块


    @spriteset = Spriteset_Battle.new


   # 此处为修改


    # 初始化我方攻击力 ######


    $game_party.actors.each {|actor| actor.atk_battler_init}


    # 初始化敌方攻击力 ######


    $game_troop.enemies.each {|enemy| enemy.atk_battler_init}


    # 初始化等待计数


    @wait_count = 0


    # 执行过渡


    if $data_system.battle_transition == ""


      Graphics.transition(20)


    else


      Graphics.transition(40, "Graphics/Transitions/" +


        $data_system.battle_transition)


    end


    # 开始自由战斗回合


    start_phase1


    # 主循环


    loop do


      # 刷新游戏画面


      Graphics.update


      # 刷新输入信息


      Input.update


      # 刷新画面


      update


      # 如果画面切换的话就中断循环


      if $scene != self


        break


      end


    end


    # 刷新地图


    $game_map.refresh


    # 准备过渡


    Graphics.freeze


    # 释放窗口


    @actor_command_window.dispose


    @party_command_window.dispose


    @help_window.dispose


    @status_window.dispose


    @message_window.dispose


    if @skill_window != nil


      @skill_window.dispose


    end


    if @item_window != nil


      @item_window.dispose


    end


    if @result_window != nil


      @result_window.dispose


    end


    # 释放活动块


    @spriteset.dispose


    # 标题画面切换中的情况


    if $scene.is_a?(Scene_Title)


      # 淡入淡出画面


      Graphics.transition


      Graphics.freeze


    end


    # 战斗测试或者游戏结束以外的画面切换中的情况


    if $BTEST and not $scene.is_a?(Scene_Gameover)


      $scene = nil


    end


  end


end

mkl7788

Cupidk爱呗茶 发表于 2020-6-7 05:41
感觉这个问题很有意思就稍微研究了一下 写的比较仓促。。有什么问题就请联系层主吧
思路大概是战斗的伤害处 ...

谢谢大神，就是这样的效果

SailCat

之前有个需求比你这个复杂的贴子，你这个需求只是他的一个子集

https://rpg.blue/thread-481866-1-1.html

RUBY 代码复制

class Game_Party
        attr_reader :buffs
        alias sailcat_initialize initialize
        def initialize
                sailcat_initialize
                @buffs = {}
        end
end
 
class Game_Battler
        alias sailcat_attack_effect attack_effect
        alias sailcat_skill_effect skill_effect
        def attack_effect(attacker)
                r = sailcat_attack_effect(attacker)
                if self.is_a?(Game_Actor) and attacker.is_a?(Game_Enemy)
                        $game_party.buffs[[self.index, :atk]] = $game_party.buffs[[self.index, :atk]].to_i - 1
                end
                r
        end
        def skill_effect(user, skill)
                r = sailcat_skill_effect(user, skill)
                if self.is_a?(Game_Actor) and attacker.is_a?(Game_Enemy)
                        $game_party.buffs[[self.index, :atk]] = $game_party.buffs[[self.index, :atk]].to_i - 1
                end
                r
        end
end
 
class Game_Actor
        def atk;        [super + $game_party.buffs[[self.index, :atk]].to_i, 0].max;        end
end

class Game_Party


        attr_reader :buffs


        alias sailcat_initialize initialize


        def initialize


                sailcat_initialize


                @buffs = {}


        end


end


 


class Game_Battler


        alias sailcat_attack_effect attack_effect


        alias sailcat_skill_effect skill_effect


        def attack_effect(attacker)


                r = sailcat_attack_effect(attacker)


                if self.is_a?(Game_Actor) and attacker.is_a?(Game_Enemy)


                        $game_party.buffs[[self.index, :atk]] = $game_party.buffs[[self.index, :atk]].to_i - 1


                end


                r


        end


        def skill_effect(user, skill)


                r = sailcat_skill_effect(user, skill)


                if self.is_a?(Game_Actor) and attacker.is_a?(Game_Enemy)


                        $game_party.buffs[[self.index, :atk]] = $game_party.buffs[[self.index, :atk]].to_i - 1


                end


                r


        end


end


 


class Game_Actor


        def atk;        [super + $game_party.buffs[[self.index, :atk]].to_i, 0].max;        end


end

另外，在战斗之后执行一下事件脚本：$game_party.buffs.clear
如果你用默认战斗的话就把上面这行插到Scene_Battle的battle_end里面：

RUBY 代码复制

class Scene_Battle
    alias sailcat_battle_end battle_end
    def battle_end(result)
         sailcat_battle_end(result)
         $game_party.buffs.clear
    end
end

class Scene_Battle


    alias sailcat_battle_end battle_end


    def battle_end(result)


         sailcat_battle_end(result)


         $game_party.buffs.clear


    end


end