都退圈了解决又有啥用？顺便告诉你只要自定义系统逻辑方面的问题想要什么都可以实现。

拙劣演技
血量还剩30%，则人物会变大，然后伤害会固定为N，对敌人伤害也会固定为N，6回合后解除，人物也会变正常

首先是血量30%变大，由于不知道你用的是什么战斗脚本，所以位置只能你自己找了，大约是描绘战斗图坐标的附近

RUBY 代码复制

# ★ 状态87：HP低于30%时 立刻2倍放大
if @battler && !@battler.dead? && !@battler.hidden
  if @battler.state?(87) && @battler.hp <= @battler.maxhp * 0.3
    self.opacity = 255
    self.color = Color.new(0,0,0,0)
    @final_zoom = @battler.real_zoom * 2.0
  else
    self.color = Color.new(0,0,0,0)
    @final_zoom = @battler.real_zoom
  end
end
 
# スプライトの座標を設定
self.x = @battler.screen_x + @effect_ox
self.y = @battler.screen_y + @effect_oy
self.z = @battler.screen_z
# 最终缩放
self.zoom_x = @final_zoom
self.zoom_y = @final_zoom

# ★ 状态87：HP低于30%时 立刻2倍放大


if @battler && !@battler.dead? && !@battler.hidden


  if @battler.state?(87) && @battler.hp <= @battler.maxhp * 0.3


    self.opacity = 255


    self.color = Color.new(0,0,0,0)


    @final_zoom = @battler.real_zoom * 2.0


  else


    self.color = Color.new(0,0,0,0)


    @final_zoom = @battler.real_zoom


  end


end


 


# スプライトの座標を設定


self.x = @battler.screen_x + @effect_ox


self.y = @battler.screen_y + @effect_oy


self.z = @battler.screen_z


# 最终缩放


self.zoom_x = @final_zoom


self.zoom_y = @final_zoom

伤害会固定为N，对敌人伤害也会固定为N
Game_Battler 3 没错，还是这个

RUBY 代码复制

# 分散
      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

# 分散


      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

下面

RUBY 代码复制

# 1. 攻击时造成的伤害固定500
  if user.state?(87) && user.hp <= user.maxhp * 0.3
    self.damage = 500
  # 2. 被攻击者时受到的伤害固定500
  elsif self.state?(87) && self.hp <= self.maxhp * 0.3
    self.damage = 500

# 1. 攻击时造成的伤害固定500


  if user.state?(87) && user.hp <= user.maxhp * 0.3


    self.damage = 500


  # 2. 被攻击者时受到的伤害固定500


  elsif self.state?(87) && self.hp <= self.maxhp * 0.3


    self.damage = 500

不是防御修正，而是分散之后，这是为了不被分散度影响

可能会出现的问题：在播放技能动画的开始，人物可能就会变大，这是因为战斗系统执行顺序的原因，默认的战斗系统是先扣血，再播放技能动画，如果在意的话你可以自己改一改

4, 碎碎念

给你一个武器附带公共事件, 平砍后就会调用对应的公共事件, 要怎么玩自己去公共事件里搞

把它塞到main前 , 然后, 武器的说明里 一样#后面不显示, 在#后面设置  公事=10086 , 这样平砍后就调用10086号公共事件

1. module RPG
   
2.   class Weapon
   
3.     def description ;return @description.split(/#/)[0] ;end
   
4.     def common_event_id ;@description[/公事=(\d+)/] ;return $1.to_i ;end
   
5.   end
   
6. end
   
7. 
   
8. class Scene_Battle
   
9.   alias caidao_make_basic_action_result make_basic_action_result
   
10.   def make_basic_action_result
    
11.     if (act=@active_battler).is_a?(Game_Actor) and
    
12.     act.current_action.basic == 0 and (wea=$data_weapons[act.weapon_id]) != nil
    
13.       @common_event_id = wea.common_event_id
    
14.     end
    
15.     caidao_make_basic_action_result
    
16.   end
    
17. end

复制代码

结合之前给你的  受方 这个函数,  去用条件分歧  受方.id == 火鸡id  给变量1 += 1  ,  这样就是砍火鸡一刀 1号变量+1,  然后在去用这个变量分歧去搞你要的表演即可

----

下面那些, 你先搞定"敌人的AI" 再说, 否则没意义, 毕竟XP默认敌人可不会判断什么情况下用什么技能 ,笑

装备绑定

把这个脚本塞到 main 前

RUBY 代码复制

module RPG
  #把要装备绑定的ID写到中括号内,武器正数,防具负数
  Arm_only = [1,-2] 
  #====================================================
  class Weapon
    def rid ;return @id ;end
    def 绑装? ;return Arm_only.include?(@id) ;end
  end
  class Armor
    def rid ;return -@id ;end
    def 绑装? ;return Arm_only.include?(-@id) ;end
  end
end
 
class Game_System
  attr_accessor :arm_only
  alias caidao_initialize initialize
  def initialize
    caidao_initialize
    @arm_only = {}
  end
end
 
class Game_Actor < Game_Battler
  def only_equip_ok?(tmrid)
    return true if !RPG::Arm_only.include?(tmrid)
    return true if (r=$game_system.arm_only[tmrid]).nil?
    return r == self.id
  end
  def weapon_set
    f=$data_classes[@class_id].weapon_set.find_all{|i| only_equip_ok?(i)}
    return f
  end
  def armor_set
    f=$data_classes[@class_id].armor_set.find_all{|i| only_equip_ok?(-i)}
    return f
  end  
  alias caidao_equippable? equippable?
  def equippable?(item)
    return false if !only_equip_ok?(item.rid)
    return caidao_equippable?(item)
  end
  alias caidao_equip equip 
  def equip(equip_type, id)
    caidao_equip(equip_type, id)
    tm = equip_type == 0 ? $data_weapons[@weapon_id] : \
    eval("$data_armors[@armor#{equip_type}_id]")
    return if tm.nil? or !tm.绑装? or $game_system.arm_only[tm.rid] != nil
    $game_system.arm_only[tm.rid] = self.id ; tm.name += "(#{self.name})"
  end
end
 
class Scene_Load < Scene_File
  alias caidao_read_save_data read_save_data
  def read_save_data(file)
    caidao_read_save_data(file)
    for i in $game_system.arm_only
      if i[0] < 0 ;$data_armors[-i[0]].name += "(#{$game_actors[i[1]].name})"
      else ;$data_weapons[i[0]].name += "(#{$game_actors[i[1]].name})"
      end
    end
  end
end

module RPG


  #把要装备绑定的ID写到中括号内,武器正数,防具负数


  Arm_only = [1,-2] 


  #====================================================


  class Weapon


    def rid ;return @id ;end


    def 绑装? ;return Arm_only.include?(@id) ;end


  end


  class Armor


    def rid ;return -@id ;end


    def 绑装? ;return Arm_only.include?(-@id) ;end


  end


end


 


class Game_System


  attr_accessor :arm_only


  alias caidao_initialize initialize


  def initialize


    caidao_initialize


    @arm_only = {}


  end


end


 


class Game_Actor < Game_Battler


  def only_equip_ok?(tmrid)


    return true if !RPG::Arm_only.include?(tmrid)


    return true if (r=$game_system.arm_only[tmrid]).nil?


    return r == self.id


  end


  def weapon_set


    f=$data_classes[@class_id].weapon_set.find_all{|i| only_equip_ok?(i)}


    return f


  end


  def armor_set


    f=$data_classes[@class_id].armor_set.find_all{|i| only_equip_ok?(-i)}


    return f


  end  


  alias caidao_equippable? equippable?


  def equippable?(item)


    return false if !only_equip_ok?(item.rid)


    return caidao_equippable?(item)


  end


  alias caidao_equip equip 


  def equip(equip_type, id)


    caidao_equip(equip_type, id)


    tm = equip_type == 0 ? $data_weapons[@weapon_id] : \


    eval("$data_armors[@armor#{equip_type}_id]")


    return if tm.nil? or !tm.绑装? or $game_system.arm_only[tm.rid] != nil


    $game_system.arm_only[tm.rid] = self.id ; tm.name += "(#{self.name})"


  end


end


 


class Scene_Load < Scene_File


  alias caidao_read_save_data read_save_data


  def read_save_data(file)


    caidao_read_save_data(file)


    for i in $game_system.arm_only


      if i[0] < 0 ;$data_armors[-i[0]].name += "(#{$game_actors[i[1]].name})"


      else ;$data_weapons[i[0]].name += "(#{$game_actors[i[1]].name})"


      end


    end


  end


end

考虑到你有可能有用装备强化脚本,装备分类脚本之类的, 之后的步骤要你自己去脚本里改,
全局搜索  $data_classes[@actor.class_id].weapon_set  把这部分改成  @actor.weapon_set  ,注意, 只改动搜索的那部分代码, 不管同一句里它前面和后面有啥玩意都不要动

然后搜索 $data_classes[@actor.class_id].armor_set 一样把它改成 @actor.armor_set

最后, 在脚本第三行的中括号内设置好要装备绑定的ID, 该ID的装备以后就只会让第一次装备它的人装备, 别人即使是相同职业也一样不能装备(初始就装备着的情况下无效)

如果想取消绑定, 执行一次 $game_system.arm_only.delete(武器为正防具为负ID)  ,  全部取消就 $game_system.arm_only.clear

属性变化, 直接用公共事件

f = [1,2,3]
a = f[rand(f.size)] ;ski= $data_skills[10086]
ski.element_set = [a]
ski.animation1_id = 10086+a  #动画根据 随机到的状态id + 固定数值来区分
ski.animation2_id = 10186+a

这样, 每次使用后,技能就会随机变成其他属性,  如果想第一次使用就随机, 那找到  Scene_Title 这个脚本, 在 Graphics.freeze 下面也加上上面那三句


注意, 如果你有使用像"多种战斗特效"这种用勾上技能属性来设置特殊效果的话,  要在 [a] 里填上你用于设置的属性ID , 例如 [a,12,14,18]  需要换行就从逗号处换

----------
其实, 如果只是属性随机变换, 那其实没啥用, 除非你能让玩家知道变换成什么属性, 这样才有一定的战略意义, 笑, 当然,这和上面一样, 如何"让玩家掌握实际信息"方面是个难点, 笑


也可以像这样,增加个被动, 让玩家可以主动控制"随机结果", 也是一种策略, 笑

我同时也有这种技能, 可以配合, 笑



-----------------------------------

另外, 如果你的属性只是体现在伤害不同上, 那属性随机其实也没什么特别之处, 反正对玩家来说, 就是冒的伤害不同罢了, 笑


我的属性攻击是会有标志以及挨打方特效表演的, 笑

技能限定伤害总量是个不错的主意, 也算是对技能使用的一种限制, 具体做法不难, 难的是"你要怎么让玩家知道每个技能的伤害剩余量", 笑

想在说明里显示变量, 那就需要改动help脚本, 如果你的技能支持多人使用, 那更要考虑"导入使用者参数", 各种麻烦事一堆哦, 笑

UI方面要怎么做自己去想,  咱就帮你实现不难的技能效果吧

首先, 在吸蓝吸血的脚本里,  def 吸蓝 这句下面, 加上一句   def damcost ;@description[/DCT\=(\d+)/] ;return $1.to_i ;end

然后, main前插入这个脚本

RUBY 代码复制

class Game_Battler
  attr_accessor :skill_damcost
  alias caidao_initialize initialize
  def initialize
    caidao_initialize
    @skill_damcost = {}
  end
  def ski_damcost(ski,dam)
    return dam if (r=ski.damcost) == 0
    @skill_damcost[ski.id] = r if @skill_damcost[ski.id].nil?
    d = [@skill_damcost[ski.id],dam].min
    @skill_damcost[ski.id] = [@skill_damcost[ski.id] - d,0].max
    return d
  end
  alias caidao_remove_states_battle remove_states_battle
  def remove_states_battle
    caidao_remove_states_battle
    @skill_damcost.clear
  end
end

class Game_Battler


  attr_accessor :skill_damcost


  alias caidao_initialize initialize


  def initialize


    caidao_initialize


    @skill_damcost = {}


  end


  def ski_damcost(ski,dam)


    return dam if (r=ski.damcost) == 0


    @skill_damcost[ski.id] = r if @skill_damcost[ski.id].nil?


    d = [@skill_damcost[ski.id],dam].min


    @skill_damcost[ski.id] = [@skill_damcost[ski.id] - d,0].max


    return d


  end


  alias caidao_remove_states_battle remove_states_battle


  def remove_states_battle


    caidao_remove_states_battle


    @skill_damcost.clear


  end


end

然后, 到 def skill_effect 这个脚本下面, 找到  self.hp -= self.damage  在它上面加上一句  self.damage = user.ski_damcost(skill,self.damage)

然后, 要限制伤害量的技能, 说明里加上  DCT=999999 , 这样,一场战斗里这个技能就只能造成999999点伤害(群攻时为伤害总和)

1，定容

伤害有容量，固定为4000，打完伤害就为0，高级技能容量大一点，比如40000

2，变化莫测

属性可变，每次属性在三个之间随机，比如火，风，水，1，2，3号属性

3，认主

装备认主，如果只是一个人可以装备，那其他职业都不打勾就可以，现在要一个认主过程，即认主后其他人不可以装备

4，碎碎念

武器会碎碎念，打多了火鸡，就有几率说，杀鸡狂魔！扩展：打多了火鸡，沾了火鸡血剑会带有火属性
时间长了，打的东西越来越多，剑会不断跳出，杀鸡狂魔，一碗虾，天马游星犬，这种空耳也可以。

5，对等协议

不要琢磨技能伤害了，直接对等协议就可以了，3回合大家都防守好了，只能加血

6，高级协议

对等协议中，双方定容都打完了，还是没死，就开始预判对面的预判，如果双方加血则都减血，双方防御都减血
动作一样就减血

7，最终协议

无论做什么都开始减血，配合假死技能，会绝地得生。敌人会预判你加血给最低血人，则触发萨菲隆一号协议
也即该人即死，要不死就用假死技能。对敌也一样，苟且偷生后偷偷干掉所有敌人，腹黑最高境界。

使用剩余回合数作为计数
记得设置好回合数，比如20回合
（如果想10回合解除就填11，20就填21）

RUBY 代码复制

if self.state?(17)
  remaining_turns = @states_turn[17]
  calculated_damage = (21 - remaining_turns) * 50
  self.damage = [calculated_damage, 9999].min
      self.hp -= self.damage
end

if self.state?(17)


  remaining_turns = @states_turn[17]


  calculated_damage = (21 - remaining_turns) * 50


  self.damage = [calculated_damage, 9999].min


      self.hp -= self.damage


end

如果想模拟无法自然解除，可以这样做：解除条件依旧是20回合，但是解除概率改成0，这样第20回合后，每回合都会扣除9999（假设你用某个方法让角色一直存活），反正9999已经是最大值了
该方法未测试，感觉应该没问题

至于还有引入变量的，因为层数是全队共享的，比如1号角色已经叠加到3层，此时2号角色再中这个状态，是从第3层开始计算的，除非你给每个角色都关联一个单独的变量
这个方法太过麻烦，所以看看就可以了

使用变量作为计数