如何让敌人有多个血条?

D-Jack

有没有办法做到回合制中打完敌人一条血后
下一层是第二条血且不同颜色的 感谢

j296196585

跟DNF一样的血条？找小黄鸡定制啊

我XP 用的是事件脚本 可惜 论坛目前不能上传图片 帮不了你 88

心六

我找到一个战斗时显示敌人血条的脚本，不过好像不能实现楼主想要的多层颜色血条，希望楼主能够采纳。
脚本原地址：

1. rpg.blue/home.php?mod=space&uid=310500&do=blog&id=10840

复制代码

更多脚本地址：

1. rpg.blue/forum.php?mod=viewthread&tid=252003&page=1

复制代码

脚本我已经复制在下面了

1. #==============================================================================
   
2. # F08 - 战斗敌人显示血条 - Ｂｙ芙蕾娅
   
3. #------------------------------------------------------------------------------
   
4. # 　★ - 新增  ☆ - 修改  ■ - 删除　● - 无变更
   
5. #==============================================================================
   
6. module Freya
   
7.   # 隐藏HP的文本
   
8.   HideGaugeText = "Hide_Gauge"
   
9.   # 血条颜色
   
10.   EnemyHPGaugeColor1 = Color.new(64,128,96)
    
11.   EnemyHPGaugeColor2 = Color.new(96,192,160)
    
12. end
    
13. #==============================================================================
    
14. # ■ Sprite_Battler_HP
    
15. #------------------------------------------------------------------------------
    
16. # 　显示战斗者的生命在战斗者的精灵下面。
    
17. #==============================================================================
    
18. class Sprite_Battler_HP < Sprite
    
19.   #--------------------------------------------------------------------------
    
20.   # ● 初始化对象
    
21.   #--------------------------------------------------------------------------
    
22.   def initialize(viewport,battler)
    
23.     super(viewport)
    
24.     @battler = battler
    
25.     @last_hp = 0
    
26.     create_bitmap
    
27.     update
    
28.   end
    
29.   #--------------------------------------------------------------------------
    
30.   # ● 释放
    
31.   #--------------------------------------------------------------------------
    
32.   def dispose
    
33.     self.bitmap.dispose
    
34.     super
    
35.   end
    
36.   #--------------------------------------------------------------------------
    
37.   # ● 生成位图
    
38.   #--------------------------------------------------------------------------
    
39.   def create_bitmap
    
40.     @last_hp = @battler.hp
    
41.     bw = 96
    
42.     bh = 6
    
43.     self.bitmap = Bitmap.new(bw, bh)
    
44.     self.bitmap.fill_rect(0, 0, bw, bh, Color.new(32,32,64))
    
45.     if Freya::Gauge_Type.nil? or Freya::Gauge_Type == 0
    
46.       hp = ((bw) * @battler.hp_rate).to_i
    
47.       self.bitmap.gradient_fill_rect(0, 0, hp, bh, Freya::EnemyHPGaugeColor1, Freya::EnemyHPGaugeColor2)
    
48.     elsif Freya::Gauge_Type == 1
    
49.       hp = ((width - 2) * @battler.hp_rate).to_i
    
50.       self.bitmap.gradient_fill_rect(1, 1, hp, bh - 2, Freya::EnemyHPGaugeColor1, Freya::EnemyHPGaugeColor2)
    
51.     elsif Freya::Gauge_Type == 2
    
52.       hp = ((width) * @battler.hp_rate).to_i
    
53.       self.bitmap.gradient_fill_rect(0, 0, hp / 2, bh, Freya::EnemyHPGaugeColor1, Freya::EnemyHPGaugeColor2)
    
54.       self.bitmap.gradient_fill_rect(hp / 2, 0, hp / 2, bh, Freya::EnemyHPGaugeColor2, Freya::EnemyHPGaugeColor1)
    
55.     elsif Freya::Gauge_Type == 3
    
56.       hp = ((width - 2) * @battler.hp_rate).to_i
    
57.       self.bitmap.gradient_fill_rect(1, 1, hp / 2, bh - 2, Freya::EnemyHPGaugeColor1, Freya::EnemyHPGaugeColor2)
    
58.       self.bitmap.gradient_fill_rect((hp / 2) + 1, 1, hp / 2, bh - 2, Freya::EnemyHPGaugeColor2, Freya::EnemyHPGaugeColor1)
    
59.     end
    
60.   end
    
61.   #--------------------------------------------------------------------------
    
62.   # ● 更新画面
    
63.   #--------------------------------------------------------------------------
    
64.   def update
    
65.     super
    
66.     unless self.bitmap.nil?
    
67.       self.x = @battler.screen_x - self.width / 2
    
68.       self.y = @battler.screen_y
    
69.       create_bitmap if @last_hp != @battler.hp
    
70.       hide = $data_enemies[@battler.enemy_id].note.include?(Freya::HideGaugeText)
    
71.       if @battler.hp == 0 or hide
    
72.         self.opacity = 0
    
73.       elsif @battler.hp > 0 && !hide
    
74.         self.opacity = 255
    
75.       end
    
76.     end
    
77.   end
    
78. end
    
79. 
    
80. #==============================================================================
    
81. # ■ Sprite_Battler
    
82. #------------------------------------------------------------------------------
    
83. # 　显示战斗者的精灵。根据 Game_Battler 类的实例自动变化。
    
84. #==============================================================================
    
85. class Sprite_Battler < Sprite_Base
    
86.   #--------------------------------------------------------------------------
    
87.   # ☆ 初始化对象
    
88.   #--------------------------------------------------------------------------
    
89.   alias initialize_freya_enemy_hp initialize
    
90.   def initialize(viewport, battler = nil)
    
91.     initialize_freya_enemy_hp(viewport, battler)
    
92.     if @battler.is_a?(Game_Enemy)
    
93.       @hp_gauge = Sprite_Battler_HP.new(viewport, battler)
    
94.     end
    
95.   end
    
96.   #--------------------------------------------------------------------------
    
97.   # ☆ 释放
    
98.   #--------------------------------------------------------------------------
    
99.   alias dispose_freya_enemy_hp dispose
    
100.   def dispose
     
101.     dispose_freya_enemy_hp
     
102.     unless @hp_gauge.nil?
     
103.       @hp_gauge.dispose
     
104.     end
     
105.   end
     
106.   #--------------------------------------------------------------------------
     
107.   # ☆ 更新画面
     
108.   #--------------------------------------------------------------------------
     
109.   alias update_freya_enemy_hp update
     
110.   def update
     
111.     update_freya_enemy_hp
     
112.     @hp_gauge.update unless @hp_gauge.nil?
     
113.   end
     
114. end

复制代码

D-Jack

心六 发表于 2017-9-28 17:47
我找到一个战斗时显示敌人血条的脚本，不过好像不能实现楼主想要的多层颜色血条，希望楼主能够采纳。
脚本 ...

45出错啊@@

心六

D-Jack 发表于 2017-9-28 22:48
45出错啊@@

那么尝试一下这个脚本，先把之前的脚本删除掉，以免起冲突，然后把这个脚本复制进去，

敌人显血

[pre lang="RGSS3"]# @taroxd metadata 1.0
# @id enemy_hp
# @display 敌人显血
# @require taroxd_core
# @require roll_gauge
# @help
#    如不想显示，可在敌人处备注 <hide hp>
#    可在敌人处备注 <hp width w>、<hp height h>、<hp dxy dx dy> 调整血槽。
#    其中 w 表示宽度、h 表示高度，dx、dy 表示坐标的偏移。

Taroxd::EnemyHP = true

class RPG::Enemy < RPG::BaseItem

  note_any :hp_dxy, [0, 0], /\s+(-?\d+)\s+(-?\d+)/, '[$1.to_i, $2.to_i]'
  note_i :hp_width, 80
  note_i :hp_height, 6
  note_bool :hide_hp?

  # 初始化并获取战斗图的尺寸
  def init_width_height
    bitmap = Bitmap.new("Graphics/Battlers/#{@battler_name}")
    @width = bitmap.width
    @height = bitmap.height
    bitmap.dispose
  end

  def width
    return @width if @width
    init_width_height
    @width
  end

  def height
    return @height if @height
    init_width_height
    @height
  end
end

class Sprite_EnemyHP < Sprite

  include Taroxd::RollGauge
  include Taroxd::DisposeBitmap

  HP_COLOR1 = Color.new(223, 127, 63)
  HP_COLOR2 = Color.new(239, 191, 63)
  BACK_COLOR = Color.new(31, 31, 63)

  def initialize(viewport, enemy)
    @enemy = enemy
    super(viewport)
    data = enemy.enemy
    @width = data.hp_width
    @height = data.hp_height
    self.bitmap = Bitmap.new(@width, @height)
    dx, dy = enemy.enemy.hp_dxy
    self.ox = @width / 2
    self.oy = @height
    self.x = enemy.screen_x + dx
    self.y = enemy.screen_y + dy
    self.z = enemy.screen_z + 10
    refresh
  end

  def make_gauge_transitions
    Transition.new(gauge_roll_times) do
      @enemy.hp.fdiv(@enemy.mhp)
    end
  end

  def update_gauge_transitions
    gauge_transitions.update
  end

  def refresh
    bitmap.clear
    rate = gauge_transitions.value
    return if rate.zero?
    fill_w = (bitmap.width * rate).to_i
    bitmap.fill_rect(fill_w, 0, @width - fill_w, @height, BACK_COLOR)
    bitmap.gradient_fill_rect(0, 0, fill_w, @height, HP_COLOR1, HP_COLOR2)
  end
end

class Spriteset_Battle

  # 导入精灵组
  def_after :create_enemies do
    @enemy_hp_sprites = $game_troop.members.map { |enemy|
      Sprite_EnemyHP.new(@viewport1, enemy) unless enemy.enemy.hide_hp?
    }.compact
  end

  def_after(:update_enemies)  { @enemy_hp_sprites.each(&:update)  }
  def_after(:dispose_enemies) { @enemy_hp_sprites.each(&:dispose) }
end[/pre]

不过使用敌人显血脚本必须同时使用Taroxd基础设置和动态值槽脚本以支援敌人显血脚本实行成功，切记一定要把这两个放在敌人显血脚本一栏的上面。

Taroxd基础设置

1. # @taroxd metadata 1.0
   
2. # @display Taroxd 基础设置
   
3. # @id taroxd_core
   
4. # @help
   
5. #
   
6. # 模块或类
   
7. #   方法名(参数) { block } / 别名 -> 返回值的类型或介绍
   
8. #     方法的介绍。
   
9. #     如果返回值没有给出，表明返回值无意义或没有确定的类型。
   
10. #
    
11. # Module
    
12. #   get_access_control(method_name) -> Symbol or nil
    
13. #     获取方法的访问控制。返回 :public, :protected, :private 或 nil（未定义）
    
14. #     method_name 为字符串或符号（Symbol），下同。
    
15. #
    
16. #   def_after(method_name) { |args| block } -> method_name
    
17. #   def_after(method_name, hook) -> method_name
    
18. #     重定义方法 method_name。
    
19. #     第一种形式中，将 block 定义为方法，在原方法之后调用。
    
20. #     第二种形式中，
    
21. #     * 如果 hook 为符号或字符串，那么会在原方法之后调用对应的方法。
    
22. #     * 如果 hook 可以响应方法 call，那么会在原方法之后调用 call。
    
23. #     * 如果 hook 是 UnboundMethod，那么会将 hook 绑定到对象后调用。
    
24. #
    
25. #     不改变原方法的返回值和访问控制。
    
26. #     无论哪种调用，参数都和原来的参数相同。
    
27. #     以下 def_* 的所有方法均有这两种形式。为了方便起见只写出第一种。
    
28. #
    
29. #     例：
    
30. #     class Game_Actor < Game_Battler
    
31. #       def_after :initialize do |actor_id|
    
32. #         @my_attribute = actor_id
    
33. #       end
    
34. #     end
    
35. #
    
36. #   def_after!(method_name) { |args| block } -> method_name
    
37. #     与 def_after 类似，但改变原方法的返回值。
    
38. #
    
39. #   def_before(method_name) { |args| block } -> method_name
    
40. #     与 def_after 类似，但在原方法之前调用。
    
41. #
    
42. #   def_with(method_name) { |old, args| block } -> method_name
    
43. #     与 def_after! 类似，但参数不同。old 参数是原方法的返回值。
    
44. #
    
45. #   def_chain(method_name) { |old, args| block } -> method_name
    
46. #     与 def_with 类似，但 old 参数为对应原方法的一个 Method 对象。
    
47. #
    
48. #   def_and(method_name) { |args| block } -> method_name
    
49. #     与 def_after 类似，但仅当原方法的返回值为真时调用。
    
50. #     仅当原方法的返回值为真时，才会改变原方法的返回值。
    
51. #
    
52. #   def_or(method_name) { |args| block } -> method_name
    
53. #     与 def_after 类似，但仅当原方法的返回值为伪时调用。
    
54. #     仅当原方法的返回值为假时，才会改变原方法的返回值。
    
55. #
    
56. #   def_if(method_name) { |args| block } -> method_name
    
57. #     与 def_before 类似，但仅当调用结果为真时调用原方法。
    
58. #     仅当调用的结果为假时，改变原方法的返回值为 nil。
    
59. #
    
60. #   def_unless(method_name) { |args| block } -> method_name
    
61. #     与 def_before 类似，但仅当调用结果为假时调用原方法。
    
62. #     仅当调用的结果为真时，改变原方法的返回值为 nil。
    
63. #
    
64. # Taroxd::ReadNote
    
65. #   该模块由以下类 extend。
    
66. #   RPG::BaseItem
    
67. #   RPG::Map
    
68. #   RPG::Event（将事件名称作为备注）
    
69. #   RPG::Tileset
    
70. #   RPG::Class::Learning
    
71. #
    
72. #   note_i(method_name, default = 0)
    
73. #     定义方法 method_name，读取备注中 <method_name x> 形式的内容。其中 x 为整数。
    
74. #     读取到的话，定义的方法会返回读取到的整数值，否则返回 default。
    
75. #
    
76. #   例：RPG::UsableItem.note_i :item_cost
    
77. #
    
78. #   note_f(method_name, default = 0.0)
    
79. #     与 note_i 类似，但读取的是实数。
    
80. #
    
81. #   note_s(method_name, default = '')
    
82. #     与 note_i 类似，但读取的是字符串。
    
83. #
    
84. #   note_bool(method_name)
    
85. #     定义 method_name 方法，判断备注中是否存在 <method_name> 子字符串。
    
86. #     特别地，若 method_name 以问号或感叹号结尾，读取内容中不需要包含问号、感叹号。
    
87. #     （上面几个方法也是一样）
    
88. #
    
89. # Taroxd::DisposeBitmap
    
90. #   dispose
    
91. #     释放位图后调用父类的 dispose 方法。
    
92. #
    
93. # Spriteset_Map / Spriteset_Battle
    
94. #   self.use_sprite(SpriteClass)
    
95. #   self.use_sprite(SpriteClass) { block }
    
96. #     在 Spriteset 中使用一个 SpriteClass 的精灵。
    
97. #     如果给出 block，则生成精灵使用的参数是 block 在 Spriteset 的上下文中执行后的返回值。
    
98. #     自动管理精灵的生成、更新、释放。
    
99. #
    
100. #    例：Spriteset_Map.use_sprite(Sprite_OnMap) { @viewport1 }
     
101. #
     
102. # Fixnum
     
103. #   id -> self
     
104. #     返回 self。这使得之后一些方法的参数既可以用数据库的数据，也可以用整数。
     
105. #
     
106. # Enumerable
     
107. #   sum(base = 0) { |element| block }
     
108. #     对所有元素 yield 后求和。base 为初始值。
     
109. #     没有 block 参数时，对所有元素求和。
     
110. #
     
111. #   例：
     
112. #   class Game_Unit
     
113. #     def tgr_sum
     
114. #       alive_members.sum(&:tgr)
     
115. #     end
     
116. #   end
     
117. #
     
118. #   pi(base = 1) { |element| block }
     
119. #     与 sum 类似，但对所有元素求积。
     
120. #
     
121. # Game_BaseItem
     
122. #   id / item_id -> Fixnum
     
123. #     返回物品 id。
     
124. #
     
125. # Game_BattlerBase
     
126. #   mtp -> Numeric
     
127. #     返回 max_tp。
     
128. #
     
129. #   initialized? -> true
     
130. #     返回 true。
     
131. #
     
132. # Game_Battler
     
133. #   note_objects -> Enumerator
     
134. #   note_objects { |obj| ... } -> self
     
135. #     迭代战斗者拥有的所有带有备注的对象。
     
136. #    （角色、职业、装备、技能、敌人、状态等）
     
137. #     没有 block 给出时，返回 Enumerator 对象。
     
138. #
     
139. #   note -> String
     
140. #     返回数据库对象的备注。
     
141. #
     
142. #   equips / weapons / armors -> []
     
143. #     返回空数组。
     
144. #
     
145. #   skill?(skill) -> true / false
     
146. #     判断是否拥有技能。skill 可以为技能 ID，也可以为 RPG::Skill 的实例。
     
147. #
     
148. #   skill_learn?(skill) -> true / false
     
149. #     判断是否习得技能。skill 可以为技能 ID，也可以为 RPG::Skill 的实例。
     
150. #
     
151. # Game_Actor
     
152. #   data_object -> RPG::Actor
     
153. #     返回数据库对象，等价于 actor。
     
154. #
     
155. #   weapon?(item) / armor?(item) -> true / false
     
156. #     检测是否装备对应的物品。item 可以为装备 ID，也可以为 RPG::EquipItem 的实例。
     
157. #
     
158. #   initialized? -> true / false
     
159. #     判断角色是否已经初始化。
     
160. #
     
161. # Game_Enemy
     
162. #   id -> Fixnum
     
163. #     返回敌人 id。
     
164. #
     
165. #   data_object -> RPG::Enemy
     
166. #     返回数据库对象，等价于 enemy。
     
167. #
     
168. #   skills -> Array
     
169. #     返回敌人的所有技能实例的数组。
     
170. #     skill? 方法判断是否拥有技能与该数组有关。
     
171. #
     
172. #   basic_skills -> Array
     
173. #     返回敌人行动列表中的技能 ID 的数组（元素可以重复）。
     
174. #     skill_learn? 方法判断是否学会技能与该数组有关。
     
175. #
     
176. # Game_Actors
     
177. #   include Enumerable
     
178. #
     
179. #   each -> Enumerator
     
180. #   each { |actor| block } -> self
     
181. #     迭代已经初始化的每个角色。
     
182. #     如果没有给出 block，返回一个 Enumerator 对象。
     
183. #
     
184. #   include?(actor)
     
185. #     角色是否已经初始化。actor 可以为 Game_Actor / RPG::Actor 的对象或 ID。
     
186. #
     
187. # Game_Unit
     
188. #   include Enumerable
     
189. #
     
190. #   each -> Enumerator
     
191. #   each { |battler| block } -> self
     
192. #     迭代队伍中的每个成员。
     
193. #     如果没有给出 block，返回一个 Enumerator 对象。
     
194. #     等价于 members.each。
     
195. #
     
196. #   each_member -> Enumerator / self
     
197. #     each 的别名。
     
198. #
     
199. #   self[*args] / slice(*args) -> Game_Actor / Array / nil
     
200. #     等价于 members[*args]
     
201. #
     
202. #   empty? -> true / false
     
203. #     判断队伍是否为空。
     
204. #
     
205. #   size / length -> Integer
     
206. #     返回队伍人数。
     
207. #
     
208. # Game_Party
     
209. #   include?(actor) -> true / false
     
210. #     队伍中是否存在角色。actor 可以为 Game_Actor / RPG::Actor 的对象或 ID。
     
211. #
     
212. # Game_Map
     
213. #   id -> Fixnum
     
214. #     返回地图 ID。
     
215. #
     
216. #   data_object -> RPG::Map
     
217. #     返回数据库对象。
     
218. #
     
219. #   note -> String
     
220. #     返回备注内容。
     
221. #
     
222. # Game_CharacterBase
     
223. #   same_pos?(character) -> true / false
     
224. #     判定是否处在相同位置。
     
225. #     character 是任意能够响应方法 x 和 y 的对象。
     
226. #     仅作为点(x, y)进行比较，不考虑 Game_Vehicle 的地图 ID 等问题。
     
227. 
     
228. module Taroxd end
     
229. 
     
230. module Taroxd::Def
     
231. 
     
232.   Singleton = Module.new { Object.send :include, self }
     
233.   Module.send :include, self
     
234. 
     
235.   def get_access_control(sym)
     
236.     return :public    if public_method_defined?    sym
     
237.     return :protected if protected_method_defined? sym
     
238.     return :private   if private_method_defined?   sym
     
239.     nil
     
240.   end
     
241. 
     
242.   template = lambda do |singleton|
     
243.     if singleton
     
244.       klass = 'singleton_class'
     
245.       get_method = 'method'
     
246.       define = 'define_singleton_method'
     
247.     else
     
248.       klass = 'self'
     
249.       get_method = 'instance_method'
     
250.       define = 'define_method'
     
251.     end
     
252.     %(
     
253.       def <name>(sym, hook = nil, &b)
     
254.         access = #{klass}.get_access_control sym
     
255.         old = #{get_method} sym
     
256.         if b
     
257.           #{define} sym, &b
     
258.           hook = #{get_method} sym
     
259.         end
     
260.         if hook.respond_to? :to_sym
     
261.           hook = hook.to_sym
     
262.           #{define} sym do |*args, &block|
     
263.             <pattern_sym>
     
264.           end
     
265.         elsif hook.respond_to? :call
     
266.           #{define} sym do |*args, &block|
     
267.             <pattern_call>
     
268.           end
     
269.         elsif hook.kind_of? UnboundMethod
     
270.           #{define} sym do |*args, &block|
     
271.             <pattern_unbound>
     
272.           end
     
273.         end
     
274.         #{klass}.__send__ access, sym
     
275.         sym
     
276.       end
     
277.     )
     
278.   end
     
279. 
     
280.   # 保存模板和替换 'hook(' 字符串的字符
     
281.   template = {false => template.call(false), true => template.call(true)}
     
282. 
     
283.   # 替换掉 pattern 中的语法
     
284.   gsub_pattern = lambda do |pattern, singleton|
     
285.     old = singleton ? 'old' : 'old.bind(self)'
     
286.     pattern.gsub('*', '*args, &block')
     
287.            .gsub(/old(\()?/) { $1 ? "#{old}.call(" : old }
     
288.   end
     
289. 
     
290.   # 存入代替 "hook(" 的字符串
     
291.   template['sym']     = '__send__(hook, '
     
292.   template['call']    = 'hook.call('
     
293.   template['unbound'] = 'hook.bind(self).call('
     
294. 
     
295.   # 获取定义方法内容的字符串
     
296.   # 得到的代码较长，请输出查看
     
297.   code = lambda do |name, pattern, singleton|
     
298.     pattern = gsub_pattern.call(pattern, singleton)
     
299.     template[singleton]
     
300.       .sub('<name>', name)
     
301.       .gsub(/<pattern_(\w+?)>/) { pattern.gsub('hook(', template[$1]) }
     
302.   end
     
303. 
     
304.   main = TOPLEVEL_BINDING.eval('self')
     
305. 
     
306.   # 定义 def_ 系列方法的方法
     
307.   define_singleton_method :def_ do |name, pattern|
     
308.     name = "#{__method__}#{name}"
     
309.     module_eval code.call(name, pattern, false)
     
310.     Singleton.module_eval code.call("singleton_#{name}", pattern, true)
     
311.     main.define_singleton_method name, &Kernel.method(name)
     
312.   end
     
313. 
     
314.   # 实际定义 def_ 系列的方法
     
315.   def_ :after,  'ret = old(*); hook(*); ret'
     
316.   def_ :after!, 'old(*); hook(*)'
     
317.   def_ :before, 'hook(*); old(*)'
     
318.   def_ :with,   'hook(old(*), *)'
     
319.   def_ :chain,  'hook(old, *)'
     
320.   def_ :and,    'old(*) && hook(*)'
     
321.   def_ :or,     'old(*) || hook(*)'
     
322.   def_ :if,     'old(*) if hook(*)'
     
323.   def_ :unless, 'old(*) unless hook(*)'
     
324. end
     
325. 
     
326. module Taroxd::ReadNote
     
327. 
     
328.   include RPG
     
329.   BaseItem.extend        self
     
330.   Map.extend             self
     
331.   Event.extend           self
     
332.   Tileset.extend         self
     
333.   Class::Learning.extend self
     
334. 
     
335.   # 获取 note 的方法
     
336.   def note_method
     
337.     :note
     
338.   end
     
339. 
     
340.   # 事件名称作为备注
     
341.   def Event.note_method
     
342.     :name
     
343.   end
     
344. 
     
345.   # 备注模板
     
346.   def note_any(name, default, re, capture)
     
347.     name = name.to_s
     
348.     mark = name.slice!(/[?!]\Z/)
     
349.     re = re.source if re.kind_of?(Regexp)
     
350.     re = "/<#{name.gsub('_', '\s*')}#{re}>/i"
     
351.     default = default.inspect
     
352.     class_eval %{
     
353.       def #{name}
     
354.         return @#{name} if instance_variable_defined? :@#{name}
     
355.         @#{name} = #{note_method} =~ #{re} ? (#{capture}) : (#{default})
     
356.       end
     
357.     }, __FILE__, __LINE__
     
358.     alias_method name + mark, name if mark
     
359.   end
     
360. 
     
361.   def note_i(name, default = 0)
     
362.     note_any(name, default, '\s*(-?\d+)', '$1.to_i')
     
363.   end
     
364. 
     
365.   def note_f(name, default = 0.0)
     
366.     note_any(name, default, '\s*(-?\d+(?:\.\d+)?)', '$1.to_f')
     
367.   end
     
368. 
     
369.   def note_s(name, default = '')
     
370.     note_any(name, default, '\s*(\S.*)', '$1')
     
371.   end
     
372. 
     
373.   def note_bool(name)
     
374.     note_any(name, false, '', 'true')
     
375.   end
     
376. end
     
377. 
     
378. module Taroxd::DisposeBitmap
     
379.   def dispose
     
380.     bitmap.dispose if bitmap
     
381.     super
     
382.   end
     
383. end
     
384. 
     
385. module Taroxd::SpritesetDSL
     
386. 
     
387.   # 方法名
     
388.   CREATE_METHOD_NAME  = :create_taroxd_sprites
     
389.   UPDATE_METHOD_NAME  = :update_taroxd_sprites
     
390.   DISPOSE_METHOD_NAME = :dispose_taroxd_sprites
     
391. 
     
392.   # 定义管理精灵的方法
     
393.   def self.extended(klass)
     
394.     klass.class_eval do
     
395.       sprites = nil
     
396. 
     
397.       define_method CREATE_METHOD_NAME do
     
398.         sprites = klass.sprite_list.map do |sprite_class, get_args|
     
399.           if get_args
     
400.             sprite_class.new(*instance_eval(&get_args))
     
401.           else
     
402.             sprite_class.new
     
403.           end
     
404.         end
     
405.       end
     
406. 
     
407.       define_method(UPDATE_METHOD_NAME)  { sprites.each(&:update)  }
     
408.       define_method(DISPOSE_METHOD_NAME) { sprites.each(&:dispose) }
     
409.     end
     
410.   end
     
411. 
     
412.   def use_sprite(klass, &get_args)
     
413.     sprite_list.push [klass, get_args]
     
414.   end
     
415. 
     
416.   def sprite_list
     
417.     @_taroxd_use_sprite ||= []
     
418.   end
     
419. 
     
420.   # 在一系列方法上触发钩子
     
421.   def sprite_method_hook(name)
     
422.     def_after :"create_#{name}",  CREATE_METHOD_NAME
     
423.     def_after :"update_#{name}",  UPDATE_METHOD_NAME
     
424.     def_after :"dispose_#{name}", DISPOSE_METHOD_NAME
     
425.   end
     
426. end
     
427. 
     
428. class Fixnum < Integer
     
429.   alias_method :id, :to_int
     
430. end
     
431. 
     
432. module Enumerable
     
433.   def sum(base = 0)
     
434.     block_given? ? inject(base) { |a, e| a + yield(e) } : inject(base, :+)
     
435.   end
     
436. 
     
437.   def pi(base = 1)
     
438.     block_given? ? inject(base) { |a, e| a * yield(e) } : inject(base, :*)
     
439.   end
     
440. end
     
441. 
     
442. class Game_BaseItem
     
443.   attr_reader :item_id
     
444.   alias_method :id, :item_id
     
445. end
     
446. 
     
447. class Game_BattlerBase
     
448. 
     
449.   def initialized?
     
450.     true
     
451.   end
     
452. 
     
453.   def mtp
     
454.     max_tp
     
455.   end
     
456. end
     
457. 
     
458. class Game_Battler < Game_BattlerBase
     
459. 
     
460.   # 迭代拥有备注的对象
     
461.   def note_objects
     
462.     return to_enum(__method__) unless block_given?
     
463.     states.each { |e| yield e }
     
464.     equips.each { |e| yield e if e }
     
465.     skills.each { |e| yield e }
     
466.     yield data_object
     
467.     yield self.class if actor?
     
468.   end
     
469. 
     
470.   def regenerate_tp
     
471.     self.tp += max_tp * trg
     
472.   end
     
473. 
     
474.   def data_object
     
475.     raise NotImplementedError
     
476.   end
     
477. 
     
478.   def note
     
479.     data_object.note
     
480.   end
     
481. 
     
482.   def id
     
483.     data_object.id
     
484.   end
     
485. 
     
486.   def skills
     
487.     (basic_skills | added_skills).sort.map { |id| $data_skills[id] }
     
488.   end
     
489. 
     
490.   def equips
     
491.     []
     
492.   end
     
493.   alias_method :weapons, :equips
     
494.   alias_method :armors,  :equips
     
495.   alias_method :basic_skills, :equips
     
496. 
     
497.   def skill?(skill)
     
498.     basic_skills.include?(skill.id) || added_skills.include?(skill.id)
     
499.   end
     
500. 
     
501.   def skill_learn?(skill)
     
502.     basic_skills.include?(skill.id)
     
503.   end
     
504. end
     
505. 
     
506. class Game_Actor < Game_Battler
     
507. 
     
508.   alias_method :data_object, :actor
     
509. 
     
510.   def weapon?(weapon)
     
511.     @equips.any? { |item| item.id == weapon.id && item.is_weapon? }
     
512.   end
     
513. 
     
514.   def armor?(armor)
     
515.     @equips.any? { |item| item.id == armor.id && item.is_armor? }
     
516.   end
     
517. 
     
518.   def initialized?
     
519.     $game_actors.include?(self)
     
520.   end
     
521. 
     
522.   private
     
523. 
     
524.   def basic_skills
     
525.     @skills
     
526.   end
     
527. end
     
528. 
     
529. class Game_Enemy < Game_Battler
     
530. 
     
531.   alias_method :data_object, :enemy
     
532.   alias_method :id, :enemy_id
     
533. 
     
534.   def basic_skills
     
535.     enemy.actions.map(&:skill_id)
     
536.   end
     
537. end
     
538. 
     
539. class Game_Actors
     
540. 
     
541.   include Enumerable
     
542. 
     
543.   def each
     
544.     return to_enum(__method__) unless block_given?
     
545.     @data.each { |actor| yield actor if actor }
     
546.     self
     
547.   end
     
548. 
     
549.   def include?(actor)
     
550.     @data[actor.id]
     
551.   end
     
552. end
     
553. 
     
554. class Game_Unit
     
555. 
     
556.   include Enumerable
     
557. 
     
558.   def to_a
     
559.     members
     
560.   end
     
561. 
     
562.   def each
     
563.     return to_enum(__method__) unless block_given?
     
564.     members.each { |battler| yield battler }
     
565.     self
     
566.   end
     
567.   alias_method :each_member, :each
     
568. 
     
569.   def [](*args)
     
570.     members[*args]
     
571.   end
     
572.   alias_method :slice, :[]
     
573. 
     
574.   def empty?
     
575.     members.empty?
     
576.   end
     
577. 
     
578.   def size
     
579.     members.size
     
580.   end
     
581.   alias_method :length, :size
     
582. end
     
583. 
     
584. class Game_Party < Game_Unit
     
585.   def include?(actor)
     
586.     @actors.include?(actor.id)
     
587.   end
     
588. end
     
589. 
     
590. class Game_Map
     
591. 
     
592.   alias_method :id, :map_id
     
593. 
     
594.   def data_object
     
595.     @map
     
596.   end
     
597. 
     
598.   def note
     
599.     @map.note
     
600.   end
     
601. end
     
602. 
     
603. class Game_CharacterBase
     
604.   def same_pos?(character)
     
605.     @x == character.x && @y == character.y
     
606.   end
     
607. end
     
608. 
     
609. class Spriteset_Map
     
610.   extend Taroxd::SpritesetDSL
     
611.   sprite_method_hook :timer
     
612. end
     
613. 
     
614. class Spriteset_Battle
     
615.   extend Taroxd::SpritesetDSL
     
616.   sprite_method_hook :timer
     
617. end

复制代码

动态值槽

1. # @taroxd metadata 1.0
   
2. # @display 动态值槽
   
3. # @require taroxd_core
   
4. # @id roll_gauge
   
5. # @help 给值槽增加动态的滚动效果
   
6. class Taroxd::Transition
   
7. 
   
8.   # value: 当前值。changing: 当前是否正在变化
   
9.   attr_reader :value, :changing
   
10. 
    
11.   # get_target.call 获取到变化的数据。可以使用 block 代替 get_target。
    
12.   def initialize(duration, get_target = nil, &block)
    
13.     @duration = duration
    
14.     @get_target = get_target || block
    
15.     @value = @target = @get_target.call
    
16.     @d = 0
    
17.   end
    
18. 
    
19.   # 更新值槽的值。如果值槽发生变化，返回 true。
    
20.   def update
    
21.     @target = @get_target.call
    
22.     @changing = @value != @target
    
23.     update_transition if @changing
    
24.     @changing
    
25.   end
    
26. 
    
27.   private
    
28. 
    
29.   def update_transition
    
30.     @d = @duration if @d.zero?
    
31.     @d -= 1
    
32.     @value = if @d.zero?
    
33.       @target
    
34.     else
    
35.       (@value * @d + @target).fdiv(@d + 1)
    
36.     end
    
37.   end
    
38. end
    
39. 
    
40. # include 之后，可用 @gauge_transitions[actor][:hp] 等
    
41. # 获取 Taroxd::Transition 的实例。
    
42. module Taroxd::RollGauge
    
43. 
    
44.   Transition = Taroxd::Transition
    
45. 
    
46.   def initialize(*)
    
47.     @gauge_transitions = make_gauge_transitions
    
48.     @gauge_roll_count = 0
    
49.     super
    
50.   end
    
51. 
    
52.   def update
    
53.     super
    
54.     if (@gauge_roll_count += 1) >= gauge_roll_interval
    
55.       roll_all_gauge if update_gauge_transitions && visible
    
56.       @gauge_roll_count = 0
    
57.     end
    
58.   end
    
59. 
    
60.   def draw_actor_hp(actor, x, y, width = 124)
    
61.     hp = @gauge_transitions[actor][:hp].value
    
62.     rate = hp.fdiv(actor.mhp)
    
63.     draw_gauge(x, y, width, rate, hp_gauge_color1, hp_gauge_color2)
    
64.     change_color(system_color)
    
65.     draw_text(x, y, 30, line_height, Vocab::hp_a)
    
66.     draw_current_and_max_values(x, y, width, hp.to_i, actor.mhp,
    
67.       hp_color(actor), normal_color)
    
68.   end
    
69. 
    
70.   def draw_actor_mp(actor, x, y, width = 124)
    
71.     mp = @gauge_transitions[actor][:mp].value
    
72.     mmp = actor.mmp
    
73.     rate = mmp.zero? ? 0 : mp.fdiv(actor.mmp)
    
74.     draw_gauge(x, y, width, rate, mp_gauge_color1, mp_gauge_color2)
    
75.     change_color(system_color)
    
76.     draw_text(x, y, 30, line_height, Vocab::mp_a)
    
77.     draw_current_and_max_values(x, y, width, mp.to_i, actor.mmp,
    
78.       mp_color(actor), normal_color)
    
79.   end
    
80. 
    
81.   def draw_actor_tp(actor, x, y, width = 124)
    
82.     tp = @gauge_transitions[actor][:tp].value
    
83.     rate = tp.fdiv(actor.max_tp)
    
84.     draw_gauge(x, y, width, rate, tp_gauge_color1, tp_gauge_color2)
    
85.     change_color(system_color)
    
86.     draw_text(x, y, 30, line_height, Vocab::tp_a)
    
87.     change_color(tp_color(actor))
    
88.     draw_text(x + width - 42, y, 42, line_height, tp.to_i, 2)
    
89.   end
    
90. 
    
91.   private
    
92. 
    
93.   # 获取 make_gauge_transitions 生成的对象
    
94.   attr_reader :gauge_transitions
    
95. 
    
96.   # 值槽滚动所需的帧数
    
97.   def gauge_roll_frame
    
98.     30
    
99.   end
    
100. 
     
101.   # 每隔多少帧更新一次值槽
     
102.   def gauge_roll_interval
     
103.     1
     
104.   end
     
105. 
     
106.   # 生成值槽变化的数据。可在子类重定义。
     
107.   # 默认的定义中，可以通过 gauge_transitions[actor][:hp] 等方式获取数据。
     
108.   def make_gauge_transitions
     
109.     Hash.new { |hash, actor|
     
110.       hash[actor] = Hash.new do |h, k|
     
111.         h[k] = Transition.new(gauge_roll_times, actor.method(k))
     
112.       end
     
113.     }.compare_by_identity
     
114.   end
     
115. 
     
116.   # 更新渐变的值。
     
117.   # 返回真值则触发一次刷新。
     
118.   # 每 gauge_roll_interval 帧调用一次。
     
119.   def update_gauge_transitions
     
120.     need_roll = false
     
121.     gauge_transitions.each_value do |hash|
     
122.       hash.each_value do |t|
     
123.         need_roll = true if t.update
     
124.       end
     
125.     end
     
126.     need_roll
     
127.   end
     
128. 
     
129.   # 值槽滚动所需的次数。
     
130.   def gauge_roll_times
     
131.     gauge_roll_frame / gauge_roll_interval
     
132.   end
     
133. 
     
134.   # 滚动所有值槽。可在子类重定义。
     
135.   def roll_all_gauge
     
136.     refresh
     
137.   end
     
138. end
     
139. 
     
140. class Window_BattleStatus
     
141.   include Taroxd::RollGauge
     
142. end
     
143. 
     
144. class Window_MenuStatus < Window_Selectable
     
145. 
     
146.   include Taroxd::RollGauge
     
147. 
     
148.   def roll_all_gauge
     
149.     item_max.times do |i|
     
150.       actor = $game_party.members[i]
     
151.       rect = item_rect(i)
     
152.       rect.x += 108
     
153.       rect.y += line_height / 2
     
154.       contents.clear_rect(rect)
     
155.       draw_actor_simple_status(actor, rect.x, rect.y)
     
156.     end
     
157.   end
     
158. end

复制代码

倘若仍有什么问题欢迎追问