我用了血条的脚本，测试的时候说NoMethodError怎么办？

zhn1997222

就是这段脚本

1. class Game_Actor < Game_Battler
   
2. def now_exp
   
3.    return @exp - @exp_list[@level]
   
4. end
   
5. def next_exp
   
6.    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
   
7. end
   
8. end
   
9. #==============================================================================
   
10. # 描绘角色血条
    
11. #==============================================================================
    
12. class Window_BattleStatus < Window_Base
    
13. #--------------------------------------------------------------------------
    
14. # ● 初始化
    
15. #--------------------------------------------------------------------------
    
16. alias xrxs_bp2_refresh refresh
    
17. def refresh
    
18.   xrxs_bp2_refresh
    
19.   @item_max = $game_party.actors.size
    
20.   for i in 0...$game_party.actors.size
    
21.     actor = $game_party.actors[i]
    
22.    
    
23.     # 血条位置修改
    
24.     actor_x = actor.screen_x + 10
    
25.     actor_y = actor.screen_y - 270
    
26.    
    
27.     x1=self.x
    
28.     y1=self.y
    
29. 
    
30.     if actor.dead? == false
    
31.       draw_actor_hp_meter(actor, actor_x, 1+actor_y,35)
    
32.       draw_actor_sp_meter(actor, actor_x, 10+actor_y, 35)
    
33.     end
    
34.   end
    
35. end
    
36. end
    
37. #==============================================================================
    
38. # ■ Window_Base
    
39. #==============================================================================
    
40. class Window_Base < Window
    
41. #--------------------------------------------------------------------------
    
42. # ● HP描画
    
43. #--------------------------------------------------------------------------
    
44. def draw_actor_hp_meter(actor, x, y, width = 156, type = 0)
    
45.   if type == 1 and actor.hp == 0
    
46.     return
    
47.   end
    
48.   self.contents.fill_rect(x-1, y+82, width+2,6, Color.new(0, 0, 0, 255))
    
49.   w = width * actor.hp / [actor.maxhp,1].max
    
50.   self.contents.fill_rect(x, y+84, w,1, Color.new(255, 140, 140, 255))
    
51.   self.contents.fill_rect(x, y+85, w,1, Color.new(180, 18, 0, 255))
    
52.   self.contents.fill_rect(x, y+86, w,1, Color.new(209, 33, 0,255))
    
53. self.contents.fill_rect(x, y+87, w,1, Color.new(180, 18, 0, 255))
    
54. end
    
55. #--------------------------------------------------------------------------
    
56. # ● SP描画
    
57. #--------------------------------------------------------------------------
    
58. def draw_actor_sp_meter(actor, x, y, width = 156, type = 0)
    
59.   if type == 1 and actor.hp == 0
    
60.     return
    
61.   end
    
62.   self.contents.fill_rect(x-1, y+82, width+2,6, Color.new(0, 0, 0, 255))
    
63.   w = width * actor.sp / [actor.maxsp,1].max
    
64.   self.contents.fill_rect(x, y+84, w,1, Color.new(40, 176, 255, 255))
    
65.   self.contents.fill_rect(x, y+85, w,1, Color.new(78, 10, 175, 255))
    
66.   self.contents.fill_rect(x, y+86, w,1, Color.new(94, 10, 214, 255))
    
67.   self.contents.fill_rect(x, y+87, w,1, Color.new(78, 10, 175, 255))
    
68. end
    
69. #--------------------------------------------------------------------------
    
70. # ● exp描画
    
71. #--------------------------------------------------------------------------
    
72. def draw_actor_exp_meter(actor, x, y, width = 156, type = 0)
    
73. if type == 1 and actor.hp == 0
    
74.    return
    
75. end
    
76. self.contents.fill_rect(x-1, y+83, width+2,6, Color.new(0, 0, 0, 255))
    
77. w = width * actor.now_exp/[ actor.next_exp,1].max
    
78. self.contents.fill_rect(x, y+83, w,1, Color.new(77, 140, 140, 255))
    
79. self.contents.fill_rect(x, y+85, w,1, Color.new(100, 220, 220, 255))
    
80. self.contents.fill_rect(x, y+86, w,1, Color.new(77, 173, 173, 255))
    
81. self.contents.fill_rect(x, y+87, w,1, Color.new(77, 207, 207, 255))
    
82. self.contents.fill_rect(x, y+87, w,1, Color.new(77, 173, 173, 255))
    
83. self.contents.fill_rect(x, y+87, w,1, Color.new(77, 140, 140, 255))
    
84. end
    
85. end
    

复制代码

zhn1997222

24行有什么问题啊，版主快来啊

zhn1997222

我是一个新手，大家帮帮忙把！

liqunsz

请上工程……
3小时内自顶+连帖小心被扣分……

反斗奇彬

脚本本身没问题，问题是lz游戏中用了什么脚本

zhn1997222

嗯，的确是

zhn1997222

我不怕q分，真的

abc1236762

1. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
2. #_/    ◆ HP/SP表示改造２ - KGC_HPSPAlter2 ◆
   
3. #_/    ◇ Last update : 2007/12/23 ◇
   
4. #_/----------------------------------------------------------------------------
   
5. #_/  HP/SP の表示形式を変更します。
   
6. #_/============================================================================
   
7. #_/  「システム系」スクリプト最上部
   
8. #_/  ≪HP/SP表示改造[HPSPAlter]≫との併用不可
   
9. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
10. 
    
11. #==============================================================================
    
12. # ★ カスタマイズ項目 ★
    
13. #==============================================================================
    
14. 
    
15. module KGC
    
16. module HPSPAlter2
    
17.   # ◆ HP ゲージ画像
    
18.   #  "Graphics/Pictures" から読み込む。
    
19.   #  拡張子省略可。
    
20.   #  HP_GAUGE = nil にすると、ゲージ非表示。
    
21.   HP_GAUGE  = "gauge_hp3"
    
22.   # ◆ SP ゲージ画像
    
23.   SP_GAUGE  = "gauge_sp3"
    
24.   # ◆ EXP (NEXT) ゲージ画像
    
25.   #  ゲージの有無は、使用する機能に依存。
    
26.   EXP_GAUGE = "gauge_exp2"
    
27. 
    
28.   # ◆非戦闘時 HP ゲージ位置 [x, y]
    
29.   #  HP 表示位置からの相対座標。
    
30.   HP_POSITION = [0, 0]
    
31.   # ◆非戦闘時 HP ゲージ長補正
    
32.   #  ゲージの長さに加算。(負にすれば短くなる)
    
33.   HP_LENGTH   = 28
    
34. 
    
35.   # ◆非戦闘時 SP ゲージ位置 [x, y]
    
36.   SP_POSITION = [0, 0]
    
37.   # ◆非戦闘時 SP ゲージ長補正
    
38.   SP_LENGTH   = 28
    
39. 
    
40.   # ◆戦闘時 HP ゲージ位置 [x, y]
    
41.   HP_POSITION_BATTLE = [0, 2]
    
42.   # ◆戦闘時 HP ゲージ長補正
    
43.   HP_LENGTH_BATTLE   = 28
    
44. 
    
45.   # ◆戦闘時 SP ゲージ位置 [x, y]
    
46.   SP_POSITION_BATTLE = [0, 2]
    
47.   # ◆戦闘時 SP ゲージ長補正
    
48.   SP_LENGTH_BATTLE   = 28
    
49. 
    
50.   # ◆ EXP ゲージ位置 [x, y]
    
51.   EXP_POSITION = [-28, 0]
    
52.   # ◆ EXP ゲージ長補正
    
53.   EXP_LENGTH   = 56
    
54. 
    
55.   # ◆ HP/SP を画像で描画
    
56.   #  画像を使用すると、HP/SP の描画が少しだけ速くなります。
    
57.   DRAW_HPSP_IMAGE = true
    
58.   # ◆数値画像
    
59.   FIGURE_NORMAL = "figure2"
    
60.   # ◆数値画像 (瀕死)
    
61.   FIGURE_CRISIS = "figure2_crisis"
    
62.   # ◆数値画像 (死亡)
    
63.   FIGURE_DEAD   = "figure2_dead"
    
64. 
    
65.   # ◆数値画像の描画位置補正 [x, y]
    
66.   DIGIT_POSITION = [0, 8]
    
67.   # ◆数値画像の描画間隔
    
68.   #  使用する数値画像に合わせて調整。
    
69.   DIGIT_SPACE = 11
    
70. 
    
71.   # ◆ステータスを影文字で描画
    
72.   #  導入した機能によって変化する場合あり。
    
73.   TEXT_SHADOW = true
    
74.   # ◆戦闘中は最大 HP/SP を描画しない
    
75.   HIDE_MAXHPSP_BATTLE = true
    
76.   # ◆文字列 "HP" を描画しない
    
77.   #  「HP 9999/9999」の "HP" を描画しなくなる。
    
78.   HIDE_HP_STRING   = true
    
79.   # ◆文字列 "SP" を描画しない
    
80.   HIDE_SP_STRING   = true
    
81.   # ◆文字列 "NEXT" を描画しない
    
82.   HIDE_NEXT_STRING = false
    
83. 
    
84.   # ◆ゲージを流す
    
85.   FLOW_GAUGE = true
    
86.   # ◆ゲージが流れる速度
    
87.   FLOW_SPEED = 4
    
88. 
    
89.   # ◆差分ゲージを描画
    
90.   DRAW_DIFF_GAUGE = true
    
91.   # ◆差分ゲージ速度
    
92.   #  数値が大きいほど減少が速い。
    
93.   DIFF_GAUGE_SPEED = 5
    
94. end
    
95. end
    
96. 
    
97. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
    
98. 
    
99. $imported = {} if $imported == nil
    
100. $imported["HPSPAlter2"] = true
     
101. 
     
102. #==============================================================================
     
103. # ■ Game_Actor
     
104. #==============================================================================
     
105. 
     
106. class Game_Actor < Game_Battler
     
107.   attr_reader :exp_list
     
108. end
     
109. 
     
110. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
111. 
     
112. #==============================================================================
     
113. # ■ Window_Base
     
114. #==============================================================================
     
115. 
     
116. class Window_Base < Window
     
117.   @@_hpsp_gauge_x = 0
     
118.   #--------------------------------------------------------------------------
     
119.   # ● ゲージ位置設定
     
120.   #--------------------------------------------------------------------------
     
121.   def self.set_hpsp_gauge_x(nx)
     
122.     @@_hpsp_gauge_x = nx
     
123.   end
     
124.   #--------------------------------------------------------------------------
     
125.   # ● 数値描画
     
126.   #     image : 数値画像
     
127.   #--------------------------------------------------------------------------
     
128.   def draw_number(image, x, y, width, height, number, align = 0)
     
129.     string = number.to_s
     
130.     space = KGC::HPSPAlter2::DIGIT_SPACE
     
131.     rect = Rect.new(0, 0, image.width / 11, image.height)
     
132.     dx = x + KGC::HPSPAlter2::DIGIT_POSITION[0]
     
133.     case align
     
134.     when 0  # 左寄せ
     
135.       dx += space * string.length
     
136.     when 1  # 中央寄せ
     
137.       dx += (width -  space * string.length) / 2
     
138.     when 2  # 右寄せ
     
139.       dx += width - rect.width
     
140.     end
     
141.     dy = y + KGC::HPSPAlter2::DIGIT_POSITION[1]
     
142.     (1..string.length).each { |i|
     
143.       char = string[-i, 1]
     
144.       if char == "/"
     
145.         n = 10
     
146.       elsif char =~ /\d/
     
147.         n = char.to_i
     
148.       else
     
149.         next
     
150.       end
     
151.       rect.x = n * rect.width
     
152.       self.contents.blt(dx, dy, image, rect)
     
153.       dx -= space
     
154.     }
     
155.   end
     
156.   #--------------------------------------------------------------------------
     
157.   # ● 描画メソッド取得
     
158.   #--------------------------------------------------------------------------
     
159.   def get_text_draw_method
     
160.     if KGC::HPSPAlter2::TEXT_SHADOW
     
161.       return self.contents.method(:draw_shadow_text)
     
162.     else
     
163.       return self.contents.method(:draw_text)
     
164.     end
     
165.   end
     
166.   #--------------------------------------------------------------------------
     
167.   # ● HP の描画
     
168.   #--------------------------------------------------------------------------
     
169.   def draw_actor_hp(actor, x, y, width = 144)
     
170.     unless $game_temp.in_battle
     
171.       draw_actor_hp_gauge(actor, x, y, width)
     
172.     end
     
173. 
     
174.     draw_method = get_text_draw_method
     
175.     # 文字列 "HP" を描画
     
176.     unless KGC::HPSPAlter2::HIDE_HP_STRING
     
177.       self.contents.font.color = system_color
     
178.       draw_method.call(x, y, 32, 32, $data_system.words.hp)
     
179.     end
     
180. 
     
181.     if KGC::HPSPAlter2::DRAW_HPSP_IMAGE
     
182.       draw_actor_hp_image(actor, x, y, width)
     
183.       return
     
184.     end
     
185. 
     
186.     # MaxHP を描画するスペースがあるか計算
     
187.     hp_x = x + width - 48
     
188.     flag = false
     
189.     if !$game_temp.in_battle || !KGC::HPSPAlter2::HIDE_MAXHPSP_BATTLE
     
190.       if width >= 108
     
191.         hp_x = x + width - 108
     
192.         flag = true
     
193.       end
     
194.     end
     
195.     # HP を描画
     
196.     self.contents.font.color = actor.hp == 0 ? knockout_color :
     
197.       actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
     
198.     draw_method.call(hp_x, y, 48, 32, actor.hp.to_s, 2)
     
199.     # MaxHP を描画
     
200.     if flag
     
201.       self.contents.font.color = normal_color
     
202.       draw_method.call(hp_x + 48, y, 12, 32, "/", 1)
     
203.       draw_method.call(hp_x + 60, y, 48, 32, actor.maxhp.to_s)
     
204.     end
     
205.   end
     
206.   #--------------------------------------------------------------------------
     
207.   # ● HP を画像で描画
     
208.   #--------------------------------------------------------------------------
     
209.   def draw_actor_hp_image(actor, x, y, width)
     
210.     # MaxHP を描画するスペースがあるか計算
     
211.     hp_x = x + width - 48
     
212.     flag = false
     
213.     if !$game_temp.in_battle || !KGC::HPSPAlter2::HIDE_MAXHPSP_BATTLE
     
214.       if width >= 108
     
215.         hp_x = x + width - 108
     
216.         flag = true
     
217.       end
     
218.     end
     
219.     # HP を描画
     
220.     if actor.hp == 0
     
221.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_DEAD)
     
222.     elsif actor.hp <= actor.maxhp / 4
     
223.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_CRISIS)
     
224.     else
     
225.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_NORMAL)
     
226.     end
     
227.     if flag
     
228.       draw_number(image, hp_x, y, 108, 32, "#{actor.hp}/#{actor.maxhp}", 2)
     
229.     else
     
230.       draw_number(image, hp_x, y, 48, 32, actor.hp.to_s, 2)
     
231.     end
     
232.   end
     
233.   #--------------------------------------------------------------------------
     
234.   # ● SP の描画
     
235.   #--------------------------------------------------------------------------
     
236.   def draw_actor_sp(actor, x, y, width = 144)
     
237.     unless $game_temp.in_battle
     
238.       draw_actor_sp_gauge(actor, x, y, width)
     
239.     end
     
240. 
     
241.     draw_method = get_text_draw_method
     
242.     # 文字列 "SP" を描画
     
243.     unless KGC::HPSPAlter2::HIDE_SP_STRING
     
244.       self.contents.font.color = system_color
     
245.       draw_method.call(x, y, 32, 32, $data_system.words.sp)
     
246.     end
     
247. 
     
248.     if KGC::HPSPAlter2::DRAW_HPSP_IMAGE
     
249.       draw_actor_sp_image(actor, x, y, width)
     
250.       return
     
251.     end
     
252. 
     
253.     # MaxSP を描画するスペースがあるか計算
     
254.     sp_x = x + width - 48
     
255.     flag = false
     
256.     if !$game_temp.in_battle || !KGC::HPSPAlter2::HIDE_MAXHPSP_BATTLE
     
257.       if width >= 108
     
258.         sp_x = x + width - 108
     
259.         flag = true
     
260.       end
     
261.     end
     
262.     # SP を描画
     
263.     self.contents.font.color = actor.sp == 0 ? knockout_color :
     
264.       actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
     
265.     draw_method.call(sp_x, y, 48, 32, actor.sp.to_s, 2)
     
266.     # MaxSP を描画
     
267.     if flag
     
268.       self.contents.font.color = normal_color
     
269.       draw_method.call(sp_x + 48, y, 12, 32, "/", 1)
     
270.       draw_method.call(sp_x + 60, y, 48, 32, actor.maxsp.to_s)
     
271.     end
     
272.   end
     
273.   #--------------------------------------------------------------------------
     
274.   # ● SP を画像で描画
     
275.   #--------------------------------------------------------------------------
     
276.   def draw_actor_sp_image(actor, x, y, width)
     
277.     # MaxSP を描画するスペースがあるか計算
     
278.     sp_x = x + width - 48
     
279.     flag = false
     
280.     if !$game_temp.in_battle || !KGC::HPSPAlter2::HIDE_MAXHPSP_BATTLE
     
281.       if width >= 108
     
282.         sp_x = x + width - 108
     
283.         flag = true
     
284.       end
     
285.     end
     
286.     # SP を描画
     
287.     if actor.sp == 0
     
288.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_DEAD)
     
289.     elsif actor.sp <= actor.maxsp / 4
     
290.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_CRISIS)
     
291.     else
     
292.       image = RPG::Cache.picture(KGC::HPSPAlter2::FIGURE_NORMAL)
     
293.     end
     
294.     if flag
     
295.       draw_number(image, sp_x, y, 108, 32, "#{actor.sp}/#{actor.maxsp}", 2)
     
296.     else
     
297.       draw_number(image, sp_x, y, 48, 32, actor.sp.to_s, 2)
     
298.     end
     
299.   end
     
300.   #--------------------------------------------------------------------------
     
301.   # ● HP ゲージの描画
     
302.   #--------------------------------------------------------------------------
     
303.   def draw_actor_hp_gauge(actor, x, y, width)
     
304.     if KGC::HPSPAlter2::HP_GAUGE == nil
     
305.       return
     
306.     end
     
307.     bitmap = self.contents
     
308.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::HP_GAUGE)
     
309.     nx = x + KGC::HPSPAlter2::HP_POSITION[0]
     
310.     ny = y + KGC::HPSPAlter2::HP_POSITION[1]
     
311.     nw = width + KGC::HPSPAlter2::HP_LENGTH
     
312.     gauge_width = calc_hp_gauge_width(actor, nw)
     
313.     draw_gauge_back(bitmap, gauge, nx, ny, nw)
     
314.     draw_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width)
     
315.     draw_gauge_fore(bitmap, gauge, nx, ny, nw)
     
316.   end
     
317.   #--------------------------------------------------------------------------
     
318.   # ● ゲージ背景の描画
     
319.   #     bitmap : 描画先画像
     
320.   #     image  : ゲージ画像
     
321.   #     width  : ゲージ幅
     
322.   #--------------------------------------------------------------------------
     
323.   def draw_gauge_back(bitmap, image, x, y, width)
     
324.     src_rect = Rect.new(0, 0, 32, 32)
     
325.     bitmap.blt(x, y, image, src_rect)
     
326.     src_rect.set(32, 0, 96, 32)
     
327.     dest_rect = Rect.new(x + 32, y, width - 64, 32)
     
328.     bitmap.stretch_blt(dest_rect, image, src_rect)
     
329.     src_rect.set(128, 0, 32, 32)
     
330.     bitmap.blt(x + width - 32, y, image, src_rect)
     
331.   end
     
332.   #--------------------------------------------------------------------------
     
333.   # ● ゲージ内部の描画
     
334.   #     bitmap : 描画先画像
     
335.   #     image  : ゲージ画像
     
336.   #     width  : ゲージ幅
     
337.   #     gauge_width : ゲージ内部の幅
     
338.   #--------------------------------------------------------------------------
     
339.   def draw_gauge_inside(bitmap, image, x, y, width, gauge_width)
     
340.     src_rect = Rect.new(@@_hpsp_gauge_x, 32, 96, 32)
     
341.     src_rect.width = gauge_width * 96 / (width - 64)
     
342.     dest_rect = Rect.new(x + 32, y, gauge_width, 32)
     
343.     bitmap.stretch_blt(dest_rect, image, src_rect)
     
344.   end
     
345.   #--------------------------------------------------------------------------
     
346.   # ● ゲージ前景の描画
     
347.   #     bitmap : 描画先画像
     
348.   #     image  : ゲージ画像
     
349.   #     width  : ゲージ幅
     
350.   #--------------------------------------------------------------------------
     
351.   def draw_gauge_fore(bitmap, image, x, y, width)
     
352.     src_rect = Rect.new(160, 0, 32, 32)
     
353.     bitmap.blt(x, y, image, src_rect)
     
354.     src_rect.set(192, 0, 96, 32)
     
355.     dest_rect = Rect.new(x + 32, y, width - 64, 32)
     
356.     bitmap.stretch_blt(dest_rect, image, src_rect)
     
357.     src_rect.set(288, 0, 32, 32)
     
358.     bitmap.blt(x + width - 32, y, image, src_rect)
     
359.   end
     
360.   #--------------------------------------------------------------------------
     
361.   # ● HP ゲージ幅の計算
     
362.   #--------------------------------------------------------------------------
     
363.   def calc_hp_gauge_width(actor, width)
     
364.     gw = actor.hp * (width - 64) / actor.maxhp
     
365.     return [[gw, 0].max, width - 64].min
     
366.   end
     
367.   #--------------------------------------------------------------------------
     
368.   # ● SP ゲージの描画
     
369.   #--------------------------------------------------------------------------
     
370.   def draw_actor_sp_gauge(actor, x, y, width)
     
371.     if KGC::HPSPAlter2::SP_GAUGE == nil
     
372.       return
     
373.     end
     
374.     bitmap = self.contents
     
375.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::SP_GAUGE)
     
376.     nx = x + KGC::HPSPAlter2::SP_POSITION[0]
     
377.     ny = y + KGC::HPSPAlter2::SP_POSITION[1]
     
378.     nw = width + KGC::HPSPAlter2::SP_LENGTH
     
379.     gauge_width = calc_sp_gauge_width(actor, nw)
     
380.     draw_gauge_back(bitmap, gauge, nx, ny, nw)
     
381.     draw_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width)
     
382.     draw_gauge_fore(bitmap, gauge, nx, ny, nw)
     
383.   end
     
384.   #--------------------------------------------------------------------------
     
385.   # ● SP ゲージ幅の計算
     
386.   #--------------------------------------------------------------------------
     
387.   def calc_sp_gauge_width(actor, width)
     
388.     gw = 0
     
389.     if actor.maxsp > 0
     
390.       gw = actor.sp * (width - 64) / actor.maxsp
     
391.     end
     
392.     return [[gw, 0].max, width - 64].min
     
393.   end
     
394.   #--------------------------------------------------------------------------
     
395.   # ● EXP の描画
     
396.   #--------------------------------------------------------------------------
     
397.   alias draw_actor_exp_KGC_HPSPAlter2 draw_actor_exp
     
398.   def draw_actor_exp(actor, x, y)
     
399.     draw_actor_exp_gauge(self.contents, actor, x, y, 204)
     
400. 
     
401.     draw_actor_exp_KGC_HPSPAlter2(actor, x, y)
     
402.   end
     
403.   #--------------------------------------------------------------------------
     
404.   # ● 次のレベルまでの EXP の描画
     
405.   #--------------------------------------------------------------------------
     
406.   def draw_actor_next_exp(actor, x, y, width = 144)
     
407.     draw_actor_exp_gauge(self.contents, actor, x, y, width)
     
408. 
     
409.     draw_method = get_text_draw_method
     
410.     # 文字列 "NEXT" を描画
     
411.     unless KGC::HPSPAlter2::HIDE_NEXT_STRING
     
412.       self.contents.font.color = system_color
     
413.       draw_method.call(x, y, 48, 32, "NEXT")
     
414.     end
     
415. 
     
416.     self.contents.font.color = normal_color
     
417.     draw_method.call(x + 48, y, width - 48, 32, actor.next_rest_exp_s, 2)
     
418.   end
     
419.   #--------------------------------------------------------------------------
     
420.   # ● EXP ゲージの描画
     
421.   #--------------------------------------------------------------------------
     
422.   def draw_actor_exp_gauge(bitmap, actor, x, y, width)
     
423.     if KGC::HPSPAlter2::EXP_GAUGE == nil
     
424.       return
     
425.     end
     
426.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::EXP_GAUGE)
     
427.     nx = x + KGC::HPSPAlter2::EXP_POSITION[0]
     
428.     ny = y + KGC::HPSPAlter2::EXP_POSITION[1]
     
429.     nw = width + KGC::HPSPAlter2::EXP_LENGTH
     
430.     gauge_width = calc_exp_gauge_width(actor, nw)
     
431.     draw_gauge_back(bitmap, gauge, nx, ny, nw)
     
432.     draw_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width)
     
433.     draw_gauge_fore(bitmap, gauge, nx, ny, nw)
     
434.   end
     
435.   #--------------------------------------------------------------------------
     
436.   # ● EXP ゲージ幅の計算
     
437.   #--------------------------------------------------------------------------
     
438.   def calc_exp_gauge_width(actor, width)
     
439.     rest_exp = actor.next_rest_exp_s.to_i
     
440.     next_exp = actor.next_exp_s.to_i - actor.exp_list[actor.level]
     
441.     gx = x
     
442.     gw = 0
     
443.     if next_exp > 0
     
444.       gw = (next_exp - rest_exp) * (width - 64) / next_exp
     
445.     end
     
446.     return [[gw, 0].max, width - 64].min
     
447.   end
     
448. end
     
449. 
     
450. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
451. 
     
452. #==============================================================================
     
453. # ■ Window_BattleStatus
     
454. #==============================================================================
     
455. 
     
456. class Window_BattleStatus < Window_Base
     
457.   #--------------------------------------------------------------------------
     
458.   # ● オブジェクト初期化
     
459.   #--------------------------------------------------------------------------
     
460.   alias initialize_KGC_HPSPAlter2 initialize
     
461.   def initialize
     
462.     @@_hpsp_gauge_x = 0
     
463.     @_current_hp = {}
     
464.     @_current_sp = {}
     
465.     @_prev_hp = {}
     
466.     @_prev_sp = {}
     
467.     $game_party.actors.each { |actor|
     
468.       @_current_hp[actor] = actor.hp
     
469.       @_prev_hp[actor] = actor.hp
     
470.       @_current_sp[actor] = actor.sp
     
471.       @_prev_sp[actor] = actor.sp
     
472.     }
     
473. 
     
474.     create_hpsp_gauge_sprite
     
475. 
     
476.     initialize_KGC_HPSPAlter2
     
477. 
     
478.     @_hpsp_gauge_sprite.x = self.x + 16
     
479.     @_hpsp_gauge_sprite.y = self.y + 16
     
480.     @_hpsp_gauge_sprite.z = self.z
     
481.   end
     
482.   #--------------------------------------------------------------------------
     
483.   # ● 解放
     
484.   #--------------------------------------------------------------------------
     
485.   alias dispose_KGC_HPSPAlter2 dispose
     
486.   def dispose
     
487.     @_hpsp_gauge_sprite.bitmap.dispose
     
488.     @_hpsp_gauge_sprite.dispose
     
489.     @_hpsp_gauge_buffer.dispose
     
490.     super
     
491.   end
     
492.   #--------------------------------------------------------------------------
     
493.   # ● HP/SPゲージスプライト作成
     
494.   #--------------------------------------------------------------------------
     
495.   def create_hpsp_gauge_sprite(viewport = nil)
     
496.     if @_hpsp_gauge_sprite != nil
     
497.       sx = @_hpsp_gauge_sprite.x
     
498.       sy = @_hpsp_gauge_sprite.y
     
499.       sz = @_hpsp_gauge_sprite.z
     
500.       @_hpsp_gauge_sprite.bitmap.dispose
     
501.       @_hpsp_gauge_sprite.dispose
     
502.       @_hpsp_gauge_buffer.dispose
     
503.     else
     
504.       sx = sy = sz = 0
     
505.     end
     
506.     @_hpsp_gauge_sprite = Sprite.new(viewport)
     
507.     @_hpsp_gauge_sprite.bitmap = Bitmap.new(608, 128)
     
508.     @_hpsp_gauge_sprite.x = sx
     
509.     @_hpsp_gauge_sprite.y = sy
     
510.     @_hpsp_gauge_sprite.z = sz
     
511. 
     
512.     @_hpsp_gauge_buffer = Bitmap.new(
     
513.       get_parameter_width + [KGC::HPSPAlter2::HP_LENGTH_BATTLE,
     
514.         KGC::HPSPAlter2::SP_LENGTH_BATTLE].max,
     
515.       128)
     
516.   end
     
517.   #--------------------------------------------------------------------------
     
518.   # ● リフレッシュ
     
519.   #--------------------------------------------------------------------------
     
520.   BATTLE_STATUS_REFRESH_CHANGED = true
     
521.   def refresh
     
522.     @_hpsp_gauge_sprite.bitmap.clear
     
523.     # ゲージ同期
     
524.     sync_gauge
     
525. 
     
526.     # パラメータ描画
     
527.     pw = get_parameter_width
     
528.     self.contents.clear
     
529.     @item_max = $game_party.actors.size
     
530.     for i in 0...$game_party.actors.size
     
531.       actor = $game_party.actors[i]
     
532.       actor_x = i * get_actor_space + 4
     
533.       draw_actor_name(actor, actor_x, 0)
     
534.       draw_actor_hp(actor, actor_x, 32, pw)
     
535.       draw_actor_sp(actor, actor_x, 64, pw)
     
536.       if @level_up_flags[i]
     
537.         self.contents.font.color = normal_color
     
538.         self.contents.draw_text(actor_x, 96, pw, 32, "LEVEL UP!")
     
539.       else
     
540.         draw_actor_state(actor, actor_x, 96)
     
541.       end
     
542.     end
     
543. 
     
544.     # ゲージ描画
     
545.     draw_hpsp_gauge_buffer(pw)
     
546.     draw_hpsp_gauge(pw)
     
547.   end
     
548.   #--------------------------------------------------------------------------
     
549.   # ● パラメータ表示幅取得
     
550.   #--------------------------------------------------------------------------
     
551.   def get_parameter_width
     
552.     return 120
     
553.   end
     
554.   #--------------------------------------------------------------------------
     
555.   # ● アクター間隔取得
     
556.   #--------------------------------------------------------------------------
     
557.   def get_actor_space
     
558.     return 160
     
559.   end
     
560.   #--------------------------------------------------------------------------
     
561.   # ● ゲージ同期
     
562.   #--------------------------------------------------------------------------
     
563.   def sync_gauge
     
564.     $game_party.actors.each { |actor|
     
565.       @_current_hp[actor] = actor.hp
     
566.       @_current_sp[actor] = actor.sp
     
567.       if @_prev_hp[actor] == nil
     
568.         @_prev_hp[actor] = actor.hp
     
569.       end
     
570.       if @_prev_sp[actor] == nil
     
571.         @_prev_sp[actor] = actor.sp
     
572.       end
     
573.     }
     
574.   end
     
575.   #--------------------------------------------------------------------------
     
576.   # ● HP/SPゲージ用バッファ描画
     
577.   #--------------------------------------------------------------------------
     
578.   def draw_hpsp_gauge_buffer(width)
     
579.     @_hpsp_gauge_buffer.clear
     
580. 
     
581.     # HP
     
582.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::HP_GAUGE)
     
583.     dw = width + KGC::HPSPAlter2::HP_LENGTH_BATTLE
     
584.     draw_gauge_back(@_hpsp_gauge_buffer, gauge, 0, 0, dw)
     
585.     draw_gauge_fore(@_hpsp_gauge_buffer, gauge, 0, 32, dw)
     
586.     # SP
     
587.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::SP_GAUGE)
     
588.     dw = width + KGC::HPSPAlter2::SP_LENGTH_BATTLE
     
589.     draw_gauge_back(@_hpsp_gauge_buffer, gauge, 0, 64, dw)
     
590.     draw_gauge_fore(@_hpsp_gauge_buffer, gauge, 0, 96, dw)
     
591.   end
     
592.   #--------------------------------------------------------------------------
     
593.   # ● HP/SPゲージ描画
     
594.   #--------------------------------------------------------------------------
     
595.   def draw_hpsp_gauge(width)
     
596.     @_hpsp_gauge_sprite.bitmap.clear
     
597.     $game_party.actors.each_with_index { |actor, i|
     
598.       actor_x = i * get_actor_space + 4
     
599.       draw_actor_hp_gauge(actor, actor_x, 32, width)
     
600.       draw_actor_sp_gauge(actor, actor_x, 64, width)
     
601.     }
     
602.   end
     
603.   #--------------------------------------------------------------------------
     
604.   # ● フレーム更新
     
605.   #--------------------------------------------------------------------------
     
606.   alias update_KGC_HPSPAlter2 update
     
607.   def update
     
608.     update_KGC_HPSPAlter2
     
609. 
     
610.     # ゲージ画像を流す
     
611.     if KGC::HPSPAlter2::FLOW_GAUGE
     
612.       flow_gauge
     
613.     end
     
614.     draw_hpsp_gauge(get_parameter_width)
     
615.   end
     
616.   #--------------------------------------------------------------------------
     
617.   # ● ゲージを流す
     
618.   #--------------------------------------------------------------------------
     
619.   def flow_gauge
     
620.     @@_hpsp_gauge_x -= KGC::HPSPAlter2::FLOW_SPEED
     
621.     if @@_hpsp_gauge_x < 0
     
622.       @@_hpsp_gauge_x += 192
     
623.     end
     
624.   end
     
625.   #--------------------------------------------------------------------------
     
626.   # ● HP ゲージの描画
     
627.   #--------------------------------------------------------------------------
     
628.   def draw_actor_hp_gauge(actor, x, y, width)
     
629.     if KGC::HPSPAlter2::HP_GAUGE == nil
     
630.       return
     
631.     end
     
632.     bitmap = @_hpsp_gauge_sprite.bitmap
     
633.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::HP_GAUGE)
     
634.     nx = x + KGC::HPSPAlter2::HP_POSITION_BATTLE[0]
     
635.     ny = y + KGC::HPSPAlter2::HP_POSITION_BATTLE[1]
     
636.     nw = width + KGC::HPSPAlter2::HP_LENGTH_BATTLE
     
637.     gauge_width = calc_hp_gauge_width(actor, nw)
     
638.     diff_gauge_width = calc_hp_diff_gauge_width(actor, nw)
     
639. 
     
640.     # 背景を転送
     
641.     bitmap.blt(nx, ny, @_hpsp_gauge_buffer, Rect.new(0, 0, nw, 32))
     
642.     # 内部を描画
     
643.     draw_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width)
     
644.     if diff_gauge_width != 0
     
645.       draw_gauge_inside_diff(bitmap, gauge, nx, ny, nw,
     
646.         gauge_width, diff_gauge_width)
     
647.     end
     
648.     # 前景を転送
     
649.     bitmap.blt(nx, ny, @_hpsp_gauge_buffer, Rect.new(0, 32, nw, 32))
     
650.   end
     
651.   #--------------------------------------------------------------------------
     
652.   # ● SP ゲージの描画
     
653.   #--------------------------------------------------------------------------
     
654.   def draw_actor_sp_gauge(actor, x, y, width)
     
655.     if KGC::HPSPAlter2::SP_GAUGE == nil
     
656.       return
     
657.     end
     
658.     bitmap = @_hpsp_gauge_sprite.bitmap
     
659.     gauge = RPG::Cache.picture(KGC::HPSPAlter2::SP_GAUGE)
     
660.     nx = x + KGC::HPSPAlter2::SP_POSITION_BATTLE[0]
     
661.     ny = y + KGC::HPSPAlter2::SP_POSITION_BATTLE[1]
     
662.     nw = width + KGC::HPSPAlter2::SP_LENGTH_BATTLE
     
663.     gauge_width = calc_sp_gauge_width(actor, nw)
     
664.     diff_gauge_width = calc_sp_diff_gauge_width(actor, nw)
     
665. 
     
666.     # 背景を転送
     
667.     bitmap.blt(nx, ny, @_hpsp_gauge_buffer, Rect.new(0, 64, nw, 32))
     
668.     # 内部を描画
     
669.     draw_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width)
     
670.     if diff_gauge_width != 0
     
671.       draw_gauge_inside_diff(bitmap, gauge, nx, ny, nw,
     
672.         gauge_width, diff_gauge_width)
     
673.     end
     
674.     # 前景を転送
     
675.     bitmap.blt(nx, ny, @_hpsp_gauge_buffer, Rect.new(0, 96, nw, 32))
     
676.   end
     
677.   #--------------------------------------------------------------------------
     
678.   # ● 差分ゲージの描画
     
679.   #     bitmap : 対象ビットマップ
     
680.   #     image  : ゲージ画像
     
681.   #     width  : ゲージ幅
     
682.   #     inside_gauge_width : ゲージ内部の幅
     
683.   #     diff_gauge_width : 差分の幅
     
684.   #--------------------------------------------------------------------------
     
685.   def draw_gauge_inside_diff(bitmap, image, x, y, width,
     
686.       inside_gauge_width, diff_gauge_width)
     
687.     src_rect = Rect.new(0, 64, 96, 32)
     
688.     src_rect.width = diff_gauge_width.abs * 96 / (width - 64)
     
689.     dest_rect = Rect.new(x + 32, y, diff_gauge_width.abs, 32)
     
690.     if diff_gauge_width > 0
     
691.       # 増加
     
692.       src_rect.x = 96
     
693.       dest_rect.x += inside_gauge_width - dest_rect.width
     
694.     else
     
695.       # 減少
     
696.       dest_rect.x += inside_gauge_width
     
697.     end
     
698.     bitmap.stretch_blt(dest_rect, image, src_rect)
     
699.   end
     
700.   #--------------------------------------------------------------------------
     
701.   # ● HP ゲージ幅の計算
     
702.   #--------------------------------------------------------------------------
     
703.   def calc_hp_gauge_width(actor, width)
     
704.     gw = @_current_hp[actor] * (width - 64) / actor.maxhp
     
705.     return [[gw, 0].max, width - 64].min
     
706.   end
     
707.   #--------------------------------------------------------------------------
     
708.   # ● HP ゲージ差分の計算
     
709.   #--------------------------------------------------------------------------
     
710.   def calc_hp_diff_gauge_width(actor, width)
     
711.     unless KGC::HPSPAlter2::DRAW_DIFF_GAUGE
     
712.       return 0
     
713.     end
     
714.     # 差分調整
     
715.     n = [actor.maxhp * KGC::HPSPAlter2::DIFF_GAUGE_SPEED / 1000, 1].max
     
716.     if @_current_hp[actor] < @_prev_hp[actor]
     
717.       # 減少中
     
718.       @_prev_hp[actor] -= n
     
719.       if @_current_hp[actor] > @_prev_hp[actor]
     
720.         @_prev_hp[actor] = @_current_hp[actor]
     
721.       end
     
722.     elsif @_current_hp[actor] > @_prev_hp[actor]
     
723.       # 増加中
     
724.       @_prev_hp[actor] += n
     
725.       if @_current_hp[actor] < @_prev_hp[actor]
     
726.         @_prev_hp[actor] = @_current_hp[actor]
     
727.       end
     
728.     end
     
729.     return (@_current_hp[actor] - @_prev_hp[actor]) * (width - 64) / actor.maxhp
     
730.   end
     
731.   #--------------------------------------------------------------------------
     
732.   # ● SP ゲージ幅の計算
     
733.   #--------------------------------------------------------------------------
     
734.   def calc_sp_gauge_width(actor, width)
     
735.     gw = 0
     
736.     if actor.maxsp > 0
     
737.       gw = @_current_sp[actor] * (width - 64) / actor.maxsp
     
738.     end
     
739.     return [[gw, 0].max, width - 64].min
     
740.   end
     
741.   #--------------------------------------------------------------------------
     
742.   # ● SP ゲージ差分の計算
     
743.   #--------------------------------------------------------------------------
     
744.   def calc_sp_diff_gauge_width(actor, width)
     
745.     if !KGC::HPSPAlter2::DRAW_DIFF_GAUGE || actor.maxsp == 0
     
746.       return 0
     
747.     end
     
748.     # 差分調整
     
749.     n = [actor.maxsp * KGC::HPSPAlter2::DIFF_GAUGE_SPEED / 1000, 1].max
     
750.     if @_current_sp[actor] < @_prev_sp[actor]
     
751.       # 減少中
     
752.       @_prev_sp[actor] -= n
     
753.       if @_current_sp[actor] > @_prev_sp[actor]
     
754.         @_prev_sp[actor] = @_current_sp[actor]
     
755.       end
     
756.     elsif @_current_sp[actor] > @_prev_sp[actor]
     
757.       # 増加中
     
758.       @_prev_sp[actor] += n
     
759.       if @_current_sp[actor] < @_prev_sp[actor]
     
760.         @_prev_sp[actor] = @_current_sp[actor]
     
761.       end
     
762.     end
     
763.     return (@_current_sp[actor] - @_prev_sp[actor]) * (width - 64) / actor.maxsp
     
764.   end
     
765. end
     
766. 
     
767. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
768. 
     
769. #==============================================================================
     
770. # ■ Scene_Battle (分割定義 1)
     
771. #==============================================================================
     
772. 
     
773. class Scene_Battle
     
774.   #--------------------------------------------------------------------------
     
775.   # ● メイン処理
     
776.   #--------------------------------------------------------------------------
     
777.   alias main_KGC_HPSPAlter2 main
     
778.   def main
     
779.     main_KGC_HPSPAlter2
     
780. 
     
781.     Window_Base.set_hpsp_gauge_x(0)
     
782.   end
     
783. end
     
784. 
     
785. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
786. 
     
787. #==============================================================================
     
788. # ■ Scene_Battle (分割定義 2)
     
789. #==============================================================================
     
790. 
     
791. class Scene_Battle
     
792.   #--------------------------------------------------------------------------
     
793.   # ● プレバトルフェーズ開始
     
794.   #--------------------------------------------------------------------------
     
795.   alias start_phase1_KGC_HPSPAlter2 start_phase1
     
796.   def start_phase1
     
797.     start_phase1_KGC_HPSPAlter2
     
798. 
     
799.     @status_window.create_hpsp_gauge_sprite(@spriteset.viewport2)
     
800.     @status_window.refresh
     
801.   end
     
802. end

复制代码

換吧
需要圖片



放到Graphics/Pictures

54cn

换一个血条脚本就可