一个日站脚本（怒气系统）的使用方法

saturnfjh

看了一个日站脚本，但是不太看得懂，也摸索了好几天，还是发现几个问题不明白：

1. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
2. #_/    ◆ オーバードライブ - KGC_OverDrive ◆ VX ◆
   
3. #_/    ◇ Last update : 2009/11/01 ◇
   
4. #_/----------------------------------------------------------------------------
   
5. #_/  専用のゲージを消費して使用するスキルを作成します。
   
6. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
7. 
   
8. #==============================================================================
   
9. # ★ カスタマイズ項目 - Customize BEGIN ★
   
10. #==============================================================================
    
11. 
    
12. module KGC
    
13. module OverDrive
    
14.   # ◆ ドライブゲージ最大値
    
15.   #  普通はこのままでOK。微調整したい場合に変更。
    
16.   GAUGE_MAX = 1000
    
17.   # ◆ ドライブゲージ増加量
    
18.   #  高いほどゲージが溜まりやすい。
    
19.   #  マイナス値を指定すると減少。
    
20.   #  「被ダメージ」は、受けたダメージの最大 HP に対する割合で増加量を算出。
    
21.   #  (500 だと、最大 HP 相当のダメージで 500 溜まる)
    
22.   GAIN_RATE = [
    
23.      80,  # 攻撃
    
24.     500,  # 被ダメージ
    
25.     200,  # 勝利
    
26.     100,  # 逃走
    
27.     160,  # 孤独
    
28.      40,  # 行動
    
29.     160,  # 瀕死
    
30.      50,  # 防御
    
31.   ]  # ← この ] は消さないこと！
    
32. 
    
33.   # ◆ ゲージの初期本数
    
34.   DEFAULT_GAUGE_NUMBER = 1
    
35. 
    
36.   # ◆ デフォルトドライブタイプ
    
37.   #   0..攻撃  1..被ダメージ  2..勝利  3..逃走  4..孤独  5..行動
    
38.   #   6..瀕死  7..防御
    
39.   DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6]        # アクター
    
40.   DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]  # 敵
    
41. 
    
42.   # ◆ ドライブゲージの色
    
43.   #  数値  : \C[n] と同じ色。
    
44.   #  Color : 指定した色。 ( Color.new(255, 128, 128) など )
    
45.   GAUGE_NORMAL_START_COLOR = 14  # 通常時開始色
    
46.   GAUGE_NORMAL_END_COLOR   =  6  # 通常時終了色
    
47.   GAUGE_MAX_START_COLOR    = 10  # 最大時開始色
    
48.   GAUGE_MAX_END_COLOR      =  2  # 最大時終了色
    
49. 
    
50.   # ◆ ドライブゲージに汎用ゲージを使用する
    
51.   #  ≪汎用ゲージ描画≫ 導入時のみ有効。
    
52.   ENABLE_GENERIC_GAUGE = true
    
53.   # ◆ ドライブゲージ設定
    
54.   #  画像は "Graphics/System" から読み込む。
    
55.   GAUGE_IMAGE     = "GaugeOD"     # 通常時画像
    
56.   GAUGE_MAX_IMAGE = "GaugeODMax"  # 最大時画像
    
57.   GAUGE_OFFSET    = [-23, -2]     # 位置補正 [x, y]
    
58.   GAUGE_LENGTH    = -4            # 長さ補正
    
59.   GAUGE_SLOPE     = 30            # 傾き (-89 ～ 89)
    
60. 
    
61.   # ◆ ドライブゲージの Y 座標補正値
    
62.   #  汎用ゲージ未使用の場合に使用。
    
63.   #  -8 にすると、HP/MP ゲージと同じ位置になります。
    
64.   GAUGE_OFFSET_Y = -8
    
65.   # ◆ ゲージ蓄積量の数値表記
    
66.   #   0 .. なし  ※ゲージが 2 本以上の場合は非推奨
    
67.   #   1 .. 即値 (蓄積量そのまま)
    
68.   #   2 .. 割合 --> x%
    
69.   #   3 .. 割合 (詳細１) --> x.x%
    
70.   #   4 .. 割合 (詳細２) --> x.xx%
    
71.   #   5 .. 蓄積済み本数
    
72.   GAUGE_VALUE_STYLE = 2
    
73.   # ◆ ゲージ蓄積量のフォントサイズ
    
74.   #  大きくしすぎると名前に被ります。
    
75.   GAUGE_VALUE_FONT_SIZE = 14
    
76. 
    
77.   # ◆ 死亡（HP 0）時にドライブゲージを 0 にする
    
78.   EMPTY_ON_DEAD = true
    
79. 
    
80.   # ◆ ドライブゲージを表示しないアクター
    
81.   #  ゲージを隠すアクターのIDを配列に格納。
    
82.   HIDE_GAUGE_ACTOR = []
    
83.   # ◆ 非戦闘時はドライブゲージを隠す
    
84.   HIDE_GAUGE_NOT_IN_BATTLE = false
    
85.   # ◆ オーバードライブスキル未修得ならゲージを隠す
    
86.   HIDE_GAUGE_NO_OD_SKILLS  = true
    
87.   # ◆ ゲージを隠している場合はゲージを増加させない
    
88.   NOT_GAIN_GAUGE_HIDING    = true
    
89. 
    
90.   # ◆ ゲージ不足のときはオーバードライブスキルを隠す
    
91.   HIDE_SKILL_LACK_OF_GAUGE = false
    
92. 
    
93.   # ◆ ドライブゲージ名
    
94.   GAUGE_NAME = "ドライブゲージ"
    
95.   # ◆ ドライブゲージ変動アイテム使用時のメッセージ
    
96.   OD_GAIN_MESSAGE = {
    
97.     :drain_a   => "%sは%sを奪われた！",  # 吸収: アクター
    
98.     :drain_e   => "%sの%sを奪った！",    # 吸収: 敵
    
99.     :loss_a    => "%sの%sが減った！",    # 減少: アクター
    
100.     :loss_e    => "%sの%sが減った！",    # 減少: 敵
     
101.     :recover_a => "%sの%sが増えた！",    # 増加: アクター
     
102.     :recover_e => "%sの%sが増えた！",    # 増加: 敵
     
103.   }
     
104. end
     
105. end
     
106. 
     
107. #==============================================================================
     
108. # ☆ カスタマイズ項目終了 - Customize END ☆
     
109. #==============================================================================
     
110. 
     
111. $imported = {} if $imported == nil
     
112. $imported["OverDrive"] = true
     
113. 
     
114. module KGC::OverDrive
     
115.   # ドライブタイプ
     
116.   module Type
     
117.     ATTACK  = 0  # 攻撃
     
118.     DAMAGE  = 1  # 被ダメージ
     
119.     VICTORY = 2  # 勝利
     
120.     ESCAPE  = 3  # 逃走
     
121.     ALONE   = 4  # 孤独
     
122.     ACTION  = 5  # 行動
     
123.     FATAL   = 6  # 瀕死
     
124.     GUARD   = 7  # 防御
     
125.   end
     
126. 
     
127.   # 蓄積量表記
     
128.   module ValueStyle
     
129.     NONE         = 0  # なし
     
130.     IMMEDIATE    = 1  # 即値
     
131.     RATE         = 2  # 割合
     
132.     RATE_DETAIL1 = 3  # 割合 (詳細１)
     
133.     RATE_DETAIL2 = 4  # 割合 (詳細２)
     
134.     NUMBER       = 5  # 蓄積済み本数
     
135.   end
     
136. 
     
137.   module Regexp
     
138.     module UsableItem
     
139.       # ドライブゲージ増加
     
140.       OD_GAIN = /<(?:OD_GAIN|(?:OD|ドライブ)ゲージ増加)\s*([\+\-]?\d+)>/i
     
141.     end
     
142. 
     
143.     module Skill
     
144.       # オーバードライブ
     
145.       OVER_DRIVE = /<(?:OVER_DRIVE|オーバードライブ)\s*(\d+)?(\+)?>/i
     
146.       # ゲージ増加率
     
147.       OD_GAIN_RATE =
     
148.         /<(?:OD_GAIN_RATE|(?:OD|ドライブ)ゲージ増加率)\s*(\d+)[%％]?>/i
     
149.     end
     
150.   end
     
151. end
     
152. 
     
153. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
154. 
     
155. #==============================================================================
     
156. # □ KGC::Commands
     
157. #==============================================================================
     
158. 
     
159. module KGC
     
160. module Commands
     
161.   module_function
     
162.   #--------------------------------------------------------------------------
     
163.   # ○ アクターのドライブゲージの増減
     
164.   #     actor_id : アクター ID (-1 : パーティ全体)
     
165.   #     value    : 増加量 (マイナスも可)
     
166.   #--------------------------------------------------------------------------
     
167.   def gain_actor_od_gauge(actor_id, value)
     
168.     if actor_id == -1
     
169.       # 生存メンバー全員のゲージを操作
     
170.       $game_party.existing_members.each { |actor|
     
171.         next unless actor.can_gain_overdrive?
     
172.         actor.overdrive += value
     
173.       }
     
174.     else
     
175.       actor = $game_actors[actor_id]
     
176.       actor.overdrive += value if actor != nil && actor.exist?
     
177.     end
     
178.   end
     
179.   #--------------------------------------------------------------------------
     
180.   # ○ エネミーのドライブゲージの増減
     
181.   #     enemy_index : エネミー index (-1 : 全体)
     
182.   #     value       : 増加量 (マイナスも可)
     
183.   #--------------------------------------------------------------------------
     
184.   def gain_enemy_od_gauge(enemy_index, value)
     
185.     if enemy_index == -1
     
186.       # 生存エネミー全員のゲージを操作
     
187.       $game_troop.existing_members.each { |enemy|
     
188.         enemy.overdrive += value
     
189.       }
     
190.     else
     
191.       enemy = $game_troop.members[enemy_index]
     
192.       enemy.overdrive += value if enemy != nil && enemy.exist?
     
193.     end
     
194.   end
     
195.   #--------------------------------------------------------------------------
     
196.   # ○ アクターのドライブゲージの取得
     
197.   #     actor_id    : アクター ID
     
198.   #     variable_id : 戻り値を格納する変数 ID
     
199.   #--------------------------------------------------------------------------
     
200.   def get_actor_od_gauge(actor_id, variable_id = 0)
     
201.     actor = $game_actors[actor_id]
     
202.     n = (actor != nil ? actor.overdrive : 0)
     
203.     if variable_id > 0
     
204.       $game_variables[variable_id] = n
     
205.     end
     
206.     return n
     
207.   end
     
208.   #--------------------------------------------------------------------------
     
209.   # ○ エネミーのドライブゲージの取得
     
210.   #     enemy_index : エネミー index
     
211.   #     variable_id : 戻り値を格納する変数 ID
     
212.   #--------------------------------------------------------------------------
     
213.   def get_enemy_od_gauge(enemy_index, variable_id = 0)
     
214.     enemy = $game_troop.members[enemy_index]
     
215.     n = (enemy != nil ? enemy.overdrive : 0)
     
216.     if variable_id > 0
     
217.       $game_variables[variable_id] = n
     
218.     end
     
219.     return n
     
220.   end
     
221.   #--------------------------------------------------------------------------
     
222.   # ○ アクターのドライブゲージの本数を設定
     
223.   #     actor_id : アクター ID (-1 : パーティ全体)
     
224.   #     number   : ゲージ本数
     
225.   #--------------------------------------------------------------------------
     
226.   def set_actor_od_gauge_number(actor_id, number)
     
227.     if actor_id == -1
     
228.       # メンバー全員の本数を設定
     
229.       $game_party.members.each { |actor|
     
230.         actor.drive_gauge_number = number
     
231.       }
     
232.     else
     
233.       actor = $game_actors[actor_id]
     
234.       actor.drive_gauge_number = number if actor != nil
     
235.     end
     
236.   end
     
237.   #--------------------------------------------------------------------------
     
238.   # ○ エネミーのドライブゲージの本数を設定
     
239.   #     enemy_index : エネミー index (-1 : 全体)
     
240.   #     number   : ゲージ本数
     
241.   #--------------------------------------------------------------------------
     
242.   def set_enemy_od_gauge_number(enemy_index, number)
     
243.     if enemy_index == -1
     
244.       # 生存エネミー全員の本数を設定
     
245.       $game_troop.members.each { |enemy|
     
246.         enemy.drive_gauge_number = number
     
247.       }
     
248.     else
     
249.       enemy = $game_troop.members[enemy_index]
     
250.       enemy.drive_gauge_number = number if enemy != nil
     
251.     end
     
252.   end
     
253.   #--------------------------------------------------------------------------
     
254.   # ○ アクターのドライブゲージが最大か判定
     
255.   #     actor_id : アクター ID
     
256.   #--------------------------------------------------------------------------
     
257.   def actor_od_gauge_max?(actor_id)
     
258.     actor = $game_actors[actor_id]
     
259.     return false if actor == nil
     
260.     return actor.overdrive == actor.max_overdrive
     
261.   end
     
262.   #--------------------------------------------------------------------------
     
263.   # ○ エネミーのドライブゲージが最大か判定
     
264.   #     enemy_index : エネミー index
     
265.   #--------------------------------------------------------------------------
     
266.   def enemy_od_gauge_max?(enemy_index)
     
267.     enemy = $game_troop.members[enemy_index]
     
268.     return false if enemy == nil
     
269.     return enemy.overdrive == enemy.max_overdrive
     
270.   end
     
271.   #--------------------------------------------------------------------------
     
272.   # ○ アクターのドライブタイプの変更
     
273.   #     actor_id : アクター ID (-1 : パーティ全体)
     
274.   #     types    : ドライブタイプの配列 (省略時 : 初期化)
     
275.   #--------------------------------------------------------------------------
     
276.   def set_actor_drive_type(actor_id, types = nil)
     
277.     if actor_id == -1
     
278.       # メンバー全員のドライブタイプを変更
     
279.       $game_party.members.each { |actor|
     
280.         actor.drive_type = types
     
281.       }
     
282.     else
     
283.       actor = $game_actors[actor_id]
     
284.       actor.drive_type = types if actor != nil
     
285.     end
     
286.   end
     
287.   #--------------------------------------------------------------------------
     
288.   # ○ エネミーのドライブタイプの変更
     
289.   #     enemy_index : エネミー index (-1 : 全体)
     
290.   #     types       : ドライブタイプの配列 (省略時 : 初期化)
     
291.   #--------------------------------------------------------------------------
     
292.   def set_enemy_drive_type(enemy_index, types = nil)
     
293.     if enemy_index == -1
     
294.       # エネミー全員のドライブタイプを変更
     
295.       $game_troop.members.each { |enemy|
     
296.         enemy.drive_type = types
     
297.       }
     
298.     else
     
299.       enemy = $game_troop.members[enemy_index]
     
300.       enemy.drive_type = types if enemy != nil
     
301.     end
     
302.   end
     
303. end
     
304. end
     
305. 
     
306. class Game_Interpreter
     
307.   include KGC::Commands
     
308. end
     
309. 
     
310. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
311. 
     
312. #==============================================================================
     
313. # ■ RPG::UsableItem
     
314. #==============================================================================
     
315. 
     
316. class RPG::UsableItem < RPG::BaseItem
     
317.   #--------------------------------------------------------------------------
     
318.   # ○ オーバードライブのキャッシュ生成
     
319.   #--------------------------------------------------------------------------
     
320.   def create_overdrive_cache
     
321.     @__od_gain = 0
     
322. 
     
323.     self.note.each_line { |line|
     
324.       case line
     
325.       when KGC::OverDrive::Regexp::UsableItem::OD_GAIN
     
326.         # ドライブゲージ増加
     
327.         @__od_gain = $1.to_i
     
328.       end
     
329.     }
     
330.   end
     
331.   #--------------------------------------------------------------------------
     
332.   # ○ ドライブゲージ増加量
     
333.   #--------------------------------------------------------------------------
     
334.   def od_gain
     
335.     create_overdrive_cache if @__od_gain == nil
     
336.     return @__od_gain
     
337.   end
     
338.   #--------------------------------------------------------------------------
     
339.   # ○ ドライブスキルであるか
     
340.   #--------------------------------------------------------------------------
     
341.   def overdrive
     
342.     return false
     
343.   end
     
344.   alias overdrive? overdrive
     
345. end
     
346. 
     
347. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
348. 
     
349. #==============================================================================
     
350. # ■ RPG::Skill
     
351. #==============================================================================
     
352. 
     
353. class RPG::Skill < RPG::UsableItem
     
354.   #--------------------------------------------------------------------------
     
355.   # ○ オーバードライブのキャッシュ生成
     
356.   #--------------------------------------------------------------------------
     
357.   def create_overdrive_cache
     
358.     super
     
359. 
     
360.     @__is_overdrive   = false
     
361.     @__od_cost        = KGC::OverDrive::GAUGE_MAX
     
362.     @__od_consume_all = false
     
363.     @__od_gain_rate   = 100
     
364. 
     
365.     self.note.each_line { |line|
     
366.       case line
     
367.       when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
     
368.         # オーバードライブ
     
369.         @__is_overdrive   = true
     
370.         @__od_cost        = $1.to_i if $1 != nil
     
371.         @__od_consume_all = ($2 != nil)
     
372.       when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
     
373.         # ゲージ増加率
     
374.         @__od_gain_rate = $1.to_i
     
375.       end
     
376.     }
     
377. 
     
378.     # ドライブスキルでなければ、ゲージ消費量 0
     
379.     unless @__is_overdrive
     
380.       @__od_cost = 0
     
381.     end
     
382.   end
     
383.   #--------------------------------------------------------------------------
     
384.   # ○ ドライブスキルであるか
     
385.   #--------------------------------------------------------------------------
     
386.   def overdrive
     
387.     create_overdrive_cache if @__is_overdrive == nil
     
388.     return @__is_overdrive
     
389.   end
     
390.   alias overdrive? overdrive
     
391.   #--------------------------------------------------------------------------
     
392.   # ○ ドライブゲージ消費量
     
393.   #--------------------------------------------------------------------------
     
394.   def od_cost
     
395.     create_overdrive_cache if @__od_cost == nil
     
396.     return @__od_cost
     
397.   end
     
398.   #--------------------------------------------------------------------------
     
399.   # ○ ドライブゲージ全消費か
     
400.   #--------------------------------------------------------------------------
     
401.   def od_consume_all
     
402.     create_overdrive_cache if @__od_consume_all == nil
     
403.     return @__od_consume_all
     
404.   end
     
405.   alias od_consume_all? od_consume_all
     
406.   #--------------------------------------------------------------------------
     
407.   # ○ ドライブゲージ増加率
     
408.   #--------------------------------------------------------------------------
     
409.   def od_gain_rate
     
410.     create_overdrive_cache if @__od_gain_rate == nil
     
411.     return @__od_gain_rate
     
412.   end
     
413. end
     
414. 
     
415. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
416. 
     
417. #==============================================================================
     
418. # ■ Vocab
     
419. #==============================================================================
     
420. 
     
421. module Vocab
     
422.   # ドライブゲージ名
     
423.   def self.overdrive
     
424.     return KGC::OverDrive::GAUGE_NAME
     
425.   end
     
426. 
     
427.   # アクター側メッセージ
     
428.   ActorODDrain    = KGC::OverDrive::OD_GAIN_MESSAGE[:drain_a]
     
429.   ActorODLoss     = KGC::OverDrive::OD_GAIN_MESSAGE[:loss_a]
     
430.   ActorODRecovery = KGC::OverDrive::OD_GAIN_MESSAGE[:recover_a]
     
431. 
     
432.   # 敵側メッセージ
     
433.   EnemyODDrain    = KGC::OverDrive::OD_GAIN_MESSAGE[:drain_e]
     
434.   EnemyODLoss     = KGC::OverDrive::OD_GAIN_MESSAGE[:loss_e]
     
435.   EnemyODRecovery = KGC::OverDrive::OD_GAIN_MESSAGE[:recover_e]
     
436. end
     
437. 
     
438. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
439. 
     
440. #==============================================================================
     
441. # ■ Game_Battler
     
442. #==============================================================================
     
443. 
     
444. class Game_Battler
     
445.   #--------------------------------------------------------------------------
     
446.   # ● 公開インスタンス変数
     
447.   #--------------------------------------------------------------------------
     
448.   attr_writer   :drive_type               # ドライブタイプ
     
449.   attr_reader   :od_damage                # 行動結果: ドライブダメージ
     
450.   #--------------------------------------------------------------------------
     
451.   # ● 行動効果の保持用変数をクリア
     
452.   #--------------------------------------------------------------------------
     
453.   alias clear_action_results_KGC_OverDrive clear_action_results
     
454.   def clear_action_results
     
455.     clear_action_results_KGC_OverDrive
     
456. 
     
457.     @od_damage = 0
     
458.   end
     
459.   #--------------------------------------------------------------------------
     
460.   # ○ ドライブゲージ量取得
     
461.   #--------------------------------------------------------------------------
     
462.   def overdrive
     
463.     @overdrive = 0 if @overdrive == nil
     
464.     return @overdrive
     
465.   end
     
466.   #--------------------------------------------------------------------------
     
467.   # ○ ドライブゲージの操作
     
468.   #--------------------------------------------------------------------------
     
469.   def overdrive=(value)
     
470.     @overdrive = [[value, max_overdrive].min, 0].max
     
471.   end
     
472.   #--------------------------------------------------------------------------
     
473.   # ○ ドライブゲージ最大量取得
     
474.   #--------------------------------------------------------------------------
     
475.   def max_overdrive
     
476.     return KGC::OverDrive::GAUGE_MAX * drive_gauge_number
     
477.   end
     
478.   #--------------------------------------------------------------------------
     
479.   # ○ ゲージ Max 判定
     
480.   #--------------------------------------------------------------------------
     
481.   def overdrive_max?
     
482.     return (overdrive == max_overdrive)
     
483.   end
     
484.   #--------------------------------------------------------------------------
     
485.   # ○ ドライブゲージ本数取得
     
486.   #--------------------------------------------------------------------------
     
487.   def drive_gauge_number
     
488.     if @drive_gauge_number == nil
     
489.       @drive_gauge_number = KGC::OverDrive::DEFAULT_GAUGE_NUMBER
     
490.     end
     
491.     return @drive_gauge_number
     
492.   end
     
493.   #--------------------------------------------------------------------------
     
494.   # ○ ドライブゲージ本数の操作
     
495.   #--------------------------------------------------------------------------
     
496.   def drive_gauge_number=(value)
     
497.     @drive_gauge_number = [value, 1].max
     
498.   end
     
499.   #--------------------------------------------------------------------------
     
500.   # ○ ドライブタイプの取得
     
501.   #--------------------------------------------------------------------------
     
502.   def drive_type
     
503.     return []
     
504.   end
     
505.   #--------------------------------------------------------------------------
     
506.   # ○ ドライブスキル習得済み判定
     
507.   #--------------------------------------------------------------------------
     
508.   def overdrive_skill_learned?
     
509.     return true
     
510.   end
     
511.   #--------------------------------------------------------------------------
     
512.   # ○ ゲージ表示判定
     
513.   #--------------------------------------------------------------------------
     
514.   def od_gauge_visible?
     
515.     return false
     
516.   end
     
517.   #--------------------------------------------------------------------------
     
518.   # ○ ゲージ増加可否判定
     
519.   #--------------------------------------------------------------------------
     
520.   def can_gain_overdrive?
     
521.     return true
     
522.   end
     
523.   #--------------------------------------------------------------------------
     
524.   # ○ 攻撃時増加判定
     
525.   #--------------------------------------------------------------------------
     
526.   def drive_attack?
     
527.     return drive_type.include?(KGC::OverDrive::Type::ATTACK)
     
528.   end
     
529.   #--------------------------------------------------------------------------
     
530.   # ○ 被ダメージ時増加判定
     
531.   #--------------------------------------------------------------------------
     
532.   def drive_damage?
     
533.     return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
     
534.   end
     
535.   #--------------------------------------------------------------------------
     
536.   # ○ 勝利時増加判定
     
537.   #--------------------------------------------------------------------------
     
538.   def drive_victory?
     
539.     return drive_type.include?(KGC::OverDrive::Type::VICTORY)
     
540.   end
     
541.   #--------------------------------------------------------------------------
     
542.   # ○ 逃走時増加判定
     
543.   #--------------------------------------------------------------------------
     
544.   def drive_escape?
     
545.     return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
     
546.   end
     
547.   #--------------------------------------------------------------------------
     
548.   # ○ 孤独時増加判定
     
549.   #--------------------------------------------------------------------------
     
550.   def drive_alone?
     
551.     return drive_type.include?(KGC::OverDrive::Type::ALONE)
     
552.   end
     
553.   #--------------------------------------------------------------------------
     
554.   # ○ 行動時増加判定
     
555.   #--------------------------------------------------------------------------
     
556.   def drive_action?
     
557.     return drive_type.include?(KGC::OverDrive::Type::ACTION)
     
558.   end
     
559.   #--------------------------------------------------------------------------
     
560.   # ○ 瀕死時増加判定
     
561.   #--------------------------------------------------------------------------
     
562.   def drive_fatal?
     
563.     return drive_type.include?(KGC::OverDrive::Type::FATAL)
     
564.   end
     
565.   #--------------------------------------------------------------------------
     
566.   # ○ 防御時増加判定
     
567.   #--------------------------------------------------------------------------
     
568.   def drive_guard?
     
569.     return drive_type.include?(KGC::OverDrive::Type::GUARD)
     
570.   end
     
571.   #--------------------------------------------------------------------------
     
572.   # ● ステートの付加
     
573.   #     state_id : ステート ID
     
574.   #--------------------------------------------------------------------------
     
575.   alias add_state_KGC_OverDrive add_state
     
576.   def add_state(state_id)
     
577.     add_state_KGC_OverDrive(state_id)
     
578. 
     
579.     reset_overdrive_on_dead if dead?
     
580.   end
     
581.   #--------------------------------------------------------------------------
     
582.   # ○ スキルの消費ドライブゲージ計算
     
583.   #     skill : スキル
     
584.   #--------------------------------------------------------------------------
     
585.   def calc_od_cost(skill)
     
586.     return 0 unless skill.is_a?(RPG::Skill)
     
587. 
     
588.     return skill.od_cost
     
589.   end
     
590.   #--------------------------------------------------------------------------
     
591.   # ● スキルの使用可能判定
     
592.   #     skill : スキル
     
593.   #--------------------------------------------------------------------------
     
594.   alias skill_can_use_KGC_OverDrive? skill_can_use?
     
595.   def skill_can_use?(skill)
     
596.     return false unless skill_can_use_KGC_OverDrive?(skill)
     
597. 
     
598.     return false if calc_od_cost(skill) > overdrive
     
599.     return true
     
600.   end
     
601.   #--------------------------------------------------------------------------
     
602.   # ● スキルまたはアイテムによるダメージ計算
     
603.   #     user : スキルまたはアイテムの使用者
     
604.   #     obj  : スキルまたはアイテム
     
605.   #    結果は @hp_damage または @mp_damage に代入する。
     
606.   #--------------------------------------------------------------------------
     
607.   alias make_obj_damage_value_KGC_OverDrive make_obj_damage_value
     
608.   def make_obj_damage_value(user, obj)
     
609.     make_obj_damage_value_KGC_OverDrive(user, obj)
     
610. 
     
611.     apply_od_consume_all_for_damage(user, obj)
     
612.   end
     
613.   #--------------------------------------------------------------------------
     
614.   # ○ ゲージ全消費時の効果の適用
     
615.   #     user : スキルまたはアイテムの使用者
     
616.   #     obj  : スキルまたはアイテム
     
617.   #    結果は @hp_damage または @mp_damage に代入する。
     
618.   #--------------------------------------------------------------------------
     
619.   def apply_od_consume_all_for_damage(user, obj)
     
620.     return unless obj.is_a?(RPG::Skill)
     
621.     return unless obj.overdrive? && obj.od_consume_all?
     
622. 
     
623.     # 余剰消費量に応じて強化 (例: 最低消費量 1000 でゲージが 1200 なら 1.2 倍)
     
624.     rate = [user.overdrive * 1000 / obj.od_cost, 1000].max
     
625.     @hp_damage = @hp_damage * rate / 1000
     
626.     @mp_damage = @mp_damage * rate / 1000
     
627.   end
     
628.   #--------------------------------------------------------------------------
     
629.   # ● ダメージの反映
     
630.   #     user : スキルかアイテムの使用者
     
631.   #    呼び出し前に @hp_damage、@mp_damage、@absorbed が設定されていること。
     
632.   #--------------------------------------------------------------------------
     
633.   alias execute_damage_KGC_OverDrive execute_damage
     
634.   def execute_damage(user)
     
635.     execute_damage_KGC_OverDrive(user)
     
636. 
     
637.     increase_overdrive(user)
     
638.     increase_overdrive_by_item(user)
     
639.   end
     
640.   #--------------------------------------------------------------------------
     
641.   # ○ 死亡時ドライブゲージ初期化処理
     
642.   #--------------------------------------------------------------------------
     
643.   def reset_overdrive_on_dead
     
644.     return unless KGC::OverDrive::EMPTY_ON_DEAD
     
645. 
     
646.     self.overdrive = 0
     
647.   end
     
648.   #--------------------------------------------------------------------------
     
649.   # ○ ドライブゲージ増加処理
     
650.   #     attacker : 攻撃者
     
651.   #--------------------------------------------------------------------------
     
652.   def increase_overdrive(attacker = nil)
     
653.     return unless attacker.is_a?(Game_Battler)  # 攻撃者がバトラーでない
     
654.     return unless actor? ^ attacker.actor?      # 攻撃側と防御側が同じ
     
655.     return if hp_damage == 0 && mp_damage == 0  # ダメージなし
     
656. 
     
657.     increase_attacker_overdrive(attacker)
     
658.     increase_defender_overdrive(attacker)
     
659.     reset_overdrive_on_dead if dead?
     
660.   end
     
661.   #--------------------------------------------------------------------------
     
662.   # ○ 攻撃側のドライブゲージ増加処理
     
663.   #     attacker : 攻撃者
     
664.   #--------------------------------------------------------------------------
     
665.   def increase_attacker_overdrive(attacker)
     
666.     return unless can_gain_overdrive?
     
667.     return unless attacker.drive_attack?  # ドライブタイプ「攻撃」なし
     
668. 
     
669.     od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
     
670.     if attacker.action.kind == 1
     
671.       rate = attacker.action.skill.od_gain_rate  # スキルの倍率を適用
     
672.       od_gain = od_gain * rate / 100
     
673.       if rate > 0
     
674.         od_gain = [od_gain, 1].max
     
675.       elsif rate < 0
     
676.         od_gain = [od_gain, -1].min
     
677.       end
     
678.     end
     
679.     attacker.overdrive += od_gain
     
680.   end
     
681.   #--------------------------------------------------------------------------
     
682.   # ○ 防御側のドライブゲージ増加処理
     
683.   #     attacker : 攻撃者
     
684.   #--------------------------------------------------------------------------
     
685.   def increase_defender_overdrive(attacker)
     
686.     return unless can_gain_overdrive?
     
687.     return unless self.drive_damage?  # ドライブタイプ「ダメージ」なし
     
688. 
     
689.     rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
     
690.     od_gain = 0
     
691.     od_gain += hp_damage * rate / maxhp if hp_damage > 0
     
692.     od_gain += mp_damage * rate / maxmp if mp_damage > 0 && maxmp > 0
     
693.     if rate > 0
     
694.       od_gain = [od_gain, 1].max
     
695.     elsif rate < 0
     
696.       od_gain = [od_gain, -1].min
     
697.     end
     
698.     self.overdrive += od_gain
     
699.   end
     
700.   #--------------------------------------------------------------------------
     
701.   # ○ アイテムによるドライブゲージ増加処理
     
702.   #     user : 使用者
     
703.   #--------------------------------------------------------------------------
     
704.   def increase_overdrive_by_item(user = nil)
     
705.     return unless user.is_a?(Game_Battler)
     
706.     return unless can_gain_overdrive?
     
707. 
     
708.     if user.action.skill?
     
709.       obj = user.action.skill
     
710.     elsif user.action.item?
     
711.       obj = user.action.item
     
712.     else
     
713.       return
     
714.     end
     
715.     @od_damage = -obj.od_gain
     
716.     self.overdrive -= @od_damage
     
717.   end
     
718.   #--------------------------------------------------------------------------
     
719.   # ● スキルの効果適用
     
720.   #     user  : スキルの使用者
     
721.   #     skill : スキル
     
722.   #--------------------------------------------------------------------------
     
723.   alias skill_effect_KGC_OverDrive skill_effect
     
724.   def skill_effect(user, skill)
     
725.     skill_effect_KGC_OverDrive(user, skill)
     
726. 
     
727.     # アイテムでスキルを発動した場合はゲージ消費判定を無視
     
728.     if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
     
729.       return
     
730.     end
     
731.   end
     
732. end
     
733. 
     
734. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
735. 
     
736. #==============================================================================
     
737. # ■ Game_Actor
     
738. #==============================================================================
     
739. 
     
740. class Game_Actor < Game_Battler
     
741.   #--------------------------------------------------------------------------
     
742.   # ● セットアップ
     
743.   #     actor_id : アクター ID
     
744.   #--------------------------------------------------------------------------
     
745.   alias setup_KGC_OverDrive setup
     
746.   def setup(actor_id)
     
747.     setup_KGC_OverDrive(actor_id)
     
748. 
     
749.     @overdrive  = 0
     
750.     @drive_type = nil
     
751.   end
     
752.   #--------------------------------------------------------------------------
     
753.   # ○ ドライブタイプの取得
     
754.   #--------------------------------------------------------------------------
     
755.   def drive_type
     
756.     unless @drive_type.is_a?(Array)
     
757.       return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
     
758.     end
     
759.     return @drive_type
     
760.   end
     
761.   #--------------------------------------------------------------------------
     
762.   # ○ ドライブスキル習得済み判定
     
763.   #--------------------------------------------------------------------------
     
764.   def overdrive_skill_learned?
     
765.     result = false
     
766.     # 一時的に戦闘中フラグを解除
     
767.     last_in_battle = $game_temp.in_battle
     
768.     $game_temp.in_battle = false
     
769. 
     
770.     self.skills.each { |skill|
     
771.       if skill.overdrive?
     
772.         result = true
     
773.         break
     
774.       end
     
775.     }
     
776.     $game_temp.in_battle = last_in_battle
     
777.     return result
     
778.   end
     
779.   #--------------------------------------------------------------------------
     
780.   # ○ ゲージ増加可否判定
     
781.   #--------------------------------------------------------------------------
     
782.   def can_gain_overdrive?
     
783.     if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
     
784.       # 非表示
     
785.       return false unless od_gauge_visible_l?
     
786.     end
     
787.     if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
     
788.       # 未修得
     
789.       return false unless overdrive_skill_learned?
     
790.     end
     
791. 
     
792.     return true
     
793.   end
     
794.   #--------------------------------------------------------------------------
     
795.   # ○ ゲージ表示判定
     
796.   #--------------------------------------------------------------------------
     
797.   def od_gauge_visible?
     
798.     return false unless od_gauge_visible_l?
     
799.     return false unless can_gain_overdrive?
     
800. 
     
801.     return true
     
802.   end
     
803.   #--------------------------------------------------------------------------
     
804.   # ○ ゲージ表示判定 (簡易版)
     
805.   #--------------------------------------------------------------------------
     
806.   def od_gauge_visible_l?
     
807.     # 戦闘中非表示
     
808.     if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
     
809.       return false
     
810.     end
     
811.     # 非表示
     
812.     return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
     
813. 
     
814.     return true
     
815.   end
     
816. end
     
817. 
     
818. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
819. 
     
820. #==============================================================================
     
821. # ■ Game_Enemy
     
822. #==============================================================================
     
823. 
     
824. class Game_Enemy < Game_Battler
     
825.   #--------------------------------------------------------------------------
     
826.   # ● オブジェクト初期化
     
827.   #     index    : 敵グループ内インデックス
     
828.   #     enemy_id : 敵キャラ ID
     
829.   #--------------------------------------------------------------------------
     
830.   alias initialize_KGC_OverDrive initialize
     
831.   def initialize(index, enemy_id)
     
832.     initialize_KGC_OverDrive(index, enemy_id)
     
833. 
     
834.     @overdrive  = 0
     
835.     @drive_type = nil
     
836.   end
     
837.   #--------------------------------------------------------------------------
     
838.   # ○ ドライブタイプの取得
     
839.   #--------------------------------------------------------------------------
     
840.   def drive_type
     
841.     unless @drive_type.is_a?(Array)
     
842.       return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
     
843.     end
     
844.     return @drive_type
     
845.   end
     
846. end
     
847. 
     
848. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
849. 
     
850. #==============================================================================
     
851. # ■ Window_Base
     
852. #==============================================================================
     
853. 
     
854. class Window_Base < Window
     
855.   #--------------------------------------------------------------------------
     
856.   # ○ ドライブゲージの通常時の色 1 の取得
     
857.   #--------------------------------------------------------------------------
     
858.   def od_gauge_normal_color1
     
859.     color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
     
860.     return (color.is_a?(Integer) ? text_color(color) : color)
     
861.   end
     
862.   #--------------------------------------------------------------------------
     
863.   # ○ ドライブゲージの通常時の色 2 の取得
     
864.   #--------------------------------------------------------------------------
     
865.   def od_gauge_normal_color2
     
866.     color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
     
867.     return (color.is_a?(Integer) ? text_color(color) : color)
     
868.   end
     
869.   #--------------------------------------------------------------------------
     
870.   # ○ ドライブゲージの最大時の色 1 の取得
     
871.   #--------------------------------------------------------------------------
     
872.   def od_gauge_max_color1
     
873.     color = KGC::OverDrive::GAUGE_MAX_START_COLOR
     
874.     return (color.is_a?(Integer) ? text_color(color) : color)
     
875.   end
     
876.   #--------------------------------------------------------------------------
     
877.   # ○ ドライブゲージの最大時の色 2 の取得
     
878.   #--------------------------------------------------------------------------
     
879.   def od_gauge_max_color2
     
880.     color = KGC::OverDrive::GAUGE_MAX_END_COLOR
     
881.     return (color.is_a?(Integer) ? text_color(color) : color)
     
882.   end
     
883.   #--------------------------------------------------------------------------
     
884.   # ● 名前の描画
     
885.   #     actor : アクター
     
886.   #     x     : 描画先 X 座標
     
887.   #     y     : 描画先 Y 座標
     
888.   #--------------------------------------------------------------------------
     
889.   alias draw_actor_name_KGC_OverDrive draw_actor_name
     
890.   def draw_actor_name(actor, x, y)
     
891.     draw_actor_od_gauge(actor, x, y, 108)
     
892. 
     
893.     draw_actor_name_KGC_OverDrive(actor, x, y)
     
894.   end
     
895.   #--------------------------------------------------------------------------
     
896.   # ○ ドライブゲージの描画
     
897.   #     actor : アクター
     
898.   #     x     : 描画先 X 座標
     
899.   #     y     : 描画先 Y 座標
     
900.   #     width : 幅
     
901.   #--------------------------------------------------------------------------
     
902.   def draw_actor_od_gauge(actor, x, y, width = 120)
     
903.     return unless actor.od_gauge_visible?
     
904. 
     
905.     n = actor.overdrive % KGC::OverDrive::GAUGE_MAX
     
906.     n = KGC::OverDrive::GAUGE_MAX if actor.overdrive_max?
     
907. 
     
908.     if KGC::OverDrive::ENABLE_GENERIC_GAUGE && $imported["GenericGauge"]
     
909.       # 汎用ゲージ
     
910.       file = (actor.overdrive_max? ?
     
911.         KGC::OverDrive::GAUGE_MAX_IMAGE : KGC::OverDrive::GAUGE_IMAGE)
     
912.       draw_gauge(file,
     
913.         x, y, width, n, KGC::OverDrive::GAUGE_MAX,
     
914.         KGC::OverDrive::GAUGE_OFFSET,
     
915.         KGC::OverDrive::GAUGE_LENGTH,
     
916.         KGC::OverDrive::GAUGE_SLOPE)
     
917.     else
     
918.       # デフォルトゲージ
     
919.       gw = width * n / KGC::OverDrive::GAUGE_MAX
     
920.       gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
     
921.       gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
     
922.       self.contents.fill_rect(x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y,
     
923.         width, 6, gauge_back_color)
     
924.       self.contents.gradient_fill_rect(
     
925.         x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y, gw, 6, gc1, gc2)
     
926.     end
     
927. 
     
928.     draw_actor_od_gauge_value(actor, x, y, width)
     
929.   end
     
930.   #--------------------------------------------------------------------------
     
931.   # ○ ドライブゲージ蓄積量の描画
     
932.   #     actor : アクター
     
933.   #     x     : 描画先 X 座標
     
934.   #     y     : 描画先 Y 座標
     
935.   #     width : 幅
     
936.   #--------------------------------------------------------------------------
     
937.   def draw_actor_od_gauge_value(actor, x, y, width = 120)
     
938.     text = ""
     
939.     value = actor.overdrive * 100.0 / KGC::OverDrive::GAUGE_MAX
     
940.     case KGC::OverDrive::GAUGE_VALUE_STYLE
     
941.     when KGC::OverDrive::ValueStyle::IMMEDIATE
     
942.       text = actor.overdrive.to_s
     
943.     when KGC::OverDrive::ValueStyle::RATE
     
944.       text = sprintf("%d%%", actor.overdrive * 100 / KGC::OverDrive::GAUGE_MAX)
     
945.     when KGC::OverDrive::ValueStyle::RATE_DETAIL1
     
946.       text = sprintf("%0.1f%%", value)
     
947.     when KGC::OverDrive::ValueStyle::RATE_DETAIL2
     
948.       text = sprintf("%0.2f%%", value)
     
949.     when KGC::OverDrive::ValueStyle::NUMBER
     
950.       text = "#{actor.overdrive / KGC::OverDrive::GAUGE_MAX}"
     
951.     else
     
952.       return
     
953.     end
     
954. 
     
955.     last_font_size = self.contents.font.size
     
956.     new_font_size  = KGC::OverDrive::GAUGE_VALUE_FONT_SIZE
     
957.     self.contents.font.size = new_font_size
     
958.     self.contents.draw_text(
     
959.       x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y - new_font_size / 2,
     
960.       width, new_font_size, text, 2)
     
961.     self.contents.font.size = last_font_size
     
962.   end
     
963. end
     
964. 
     
965. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
966. 
     
967. #==============================================================================
     
968. # ■ Window_Skill
     
969. #==============================================================================
     
970. 
     
971. if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
     
972. 
     
973. class Window_Skill < Window_Selectable
     
974.   #--------------------------------------------------------------------------
     
975.   # ○ スキルをリストに含めるかどうか
     
976.   #     skill : スキル
     
977.   #--------------------------------------------------------------------------
     
978.   unless $@
     
979.     alias include_KGC_OverDrive? include? if method_defined?(:include?)
     
980.   end
     
981.   def include?(skill)
     
982.     return false if skill == nil
     
983. 
     
984.     if defined?(include_KGC_OverDrive?)
     
985.       return false unless include_KGC_OverDrive?(skill)
     
986.     end
     
987. 
     
988.     if skill.overdrive?
     
989.       return (@actor.calc_od_cost(skill) <= @actor.overdrive)
     
990.     else
     
991.       return true
     
992.     end
     
993.   end
     
994. 
     
995. if method_defined?(:include_KGC_OverDrive?)
     
996.   #--------------------------------------------------------------------------
     
997.   # ● リフレッシュ
     
998.   #--------------------------------------------------------------------------
     
999.   def refresh
     
1000.     @data = []
      
1001.     for skill in @actor.skills
      
1002.       next unless include?(skill)
      
1003.       @data.push(skill)
      
1004.       if skill.id == @actor.last_skill_id
      
1005.         self.index = @data.size - 1
      
1006.       end
      
1007.     end
      
1008.     @item_max = @data.size
      
1009.     create_contents
      
1010.     for i in 0...@item_max
      
1011.       draw_item(i)
      
1012.     end
      
1013.   end
      
1014. end
      
1015. 
      
1016. end  # <-- class
      
1017. end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
      
1018. 
      
1019. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
      
1020. 
      
1021. #==============================================================================
      
1022. # ■ Scene_Skill
      
1023. #==============================================================================
      
1024. 
      
1025. class Scene_Skill < Scene_Base
      
1026.   #--------------------------------------------------------------------------
      
1027.   # ● スキルの使用 (味方対象以外の使用効果を適用)
      
1028.   #--------------------------------------------------------------------------
      
1029.   alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
      
1030.   def use_skill_nontarget
      
1031.     consume_od_gauge
      
1032. 
      
1033.     use_skill_nontarget_KGC_OverDrive
      
1034.   end
      
1035.   #--------------------------------------------------------------------------
      
1036.   # ○ スキル使用時のドライブゲージ消費
      
1037.   #--------------------------------------------------------------------------
      
1038.   def consume_od_gauge
      
1039.     if @skill.od_consume_all?
      
1040.       @actor.overdrive = 0
      
1041.     else
      
1042.       @actor.overdrive -= @actor.calc_od_cost(@skill)
      
1043.     end
      
1044.   end
      
1045. end
      
1046. 
      
1047. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
      
1048. 
      
1049. #==============================================================================
      
1050. # ■ Scene_Battle
      
1051. #==============================================================================
      
1052. 
      
1053. class Scene_Battle < Scene_Base
      
1054.   #--------------------------------------------------------------------------
      
1055.   # ● 戦闘終了
      
1056.   #     result : 結果 (0:勝利 1:逃走 2:敗北)
      
1057.   #--------------------------------------------------------------------------
      
1058.   alias battle_end_KGC_OverDrive battle_end
      
1059.   def battle_end(result)
      
1060.     increase_overdrive_on_battle_end(result)
      
1061. 
      
1062.     battle_end_KGC_OverDrive(result)
      
1063.   end
      
1064.   #--------------------------------------------------------------------------
      
1065.   # ○ 戦闘終了時のドライブゲージ増加処理
      
1066.   #     result : 結果 (0:勝利 1:逃走 2:敗北)
      
1067.   #--------------------------------------------------------------------------
      
1068.   def increase_overdrive_on_battle_end(result)
      
1069.     case result
      
1070.     when 0  # 勝利
      
1071.       od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
      
1072.       $game_party.existing_members.each { |actor|
      
1073.         actor.overdrive += od_gain if actor.drive_victory?
      
1074.       }
      
1075.     when 1  # 逃走
      
1076.       od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
      
1077.       $game_party.existing_members.each { |actor|
      
1078.         actor.overdrive += od_gain if actor.drive_escape?
      
1079.       }
      
1080.     end
      
1081.   end
      
1082.   #--------------------------------------------------------------------------
      
1083.   # ● 戦闘行動の実行
      
1084.   #--------------------------------------------------------------------------
      
1085.   alias execute_action_KGC_OverDrive execute_action
      
1086.   def execute_action
      
1087.     increase_overdrive_on_action
      
1088. 
      
1089.     execute_action_KGC_OverDrive
      
1090.   end
      
1091.   #--------------------------------------------------------------------------
      
1092.   # ○ 行動時のドライブゲージ増加処理
      
1093.   #--------------------------------------------------------------------------
      
1094.   def increase_overdrive_on_action
      
1095.     battler = @active_battler
      
1096.     od_gain = 0
      
1097.     unit = (battler.actor? ? $game_party : $game_troop)
      
1098. 
      
1099.     # 孤独戦闘
      
1100.     if battler.drive_alone? && unit.existing_members.size == 1
      
1101.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
      
1102.     end
      
1103.     # 行動
      
1104.     if battler.drive_action?
      
1105.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
      
1106.     end
      
1107.     # 瀕死
      
1108.     if battler.drive_fatal? && battler.hp < battler.maxhp / 4
      
1109.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
      
1110.     end
      
1111.     # 防御
      
1112.     if battler.drive_guard? && battler.action.kind == 0 &&
      
1113.         battler.action.basic == 1
      
1114.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD]
      
1115.     end
      
1116.     battler.overdrive += od_gain
      
1117.   end
      
1118.   #--------------------------------------------------------------------------
      
1119.   # ● 戦闘行動の実行 : スキル
      
1120.   #--------------------------------------------------------------------------
      
1121.   alias execute_action_skill_KGC_OverDrive execute_action_skill
      
1122.   def execute_action_skill
      
1123.     execute_action_skill_KGC_OverDrive
      
1124. 
      
1125.     consume_od_gauge
      
1126.   end
      
1127.   #--------------------------------------------------------------------------
      
1128.   # ○ スキル使用時のドライブゲージ消費
      
1129.   #--------------------------------------------------------------------------
      
1130.   def consume_od_gauge
      
1131.     return unless @active_battler.action.skill?
      
1132. 
      
1133.     skill = @active_battler.action.skill
      
1134.     if skill.od_consume_all?
      
1135.       @active_battler.overdrive = 0
      
1136.     else
      
1137.       @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
      
1138.     end
      
1139.   end
      
1140.   #--------------------------------------------------------------------------
      
1141.   # ● ダメージの表示
      
1142.   #     target : 対象者
      
1143.   #     obj    : スキルまたはアイテム
      
1144.   #--------------------------------------------------------------------------
      
1145.   alias display_damage_KGC_OverDrive display_damage
      
1146.   def display_damage(target, obj = nil)
      
1147.     display_damage_KGC_OverDrive(target, obj)
      
1148. 
      
1149.     return if target.missed || target.evaded
      
1150.     display_od_damage(target, obj)
      
1151.   end
      
1152.   #--------------------------------------------------------------------------
      
1153.   # ○ ドライブダメージ表示
      
1154.   #     target : 対象者
      
1155.   #     obj    : スキルまたはアイテム
      
1156.   #--------------------------------------------------------------------------
      
1157.   def display_od_damage(target, obj = nil)
      
1158.     return if target.dead?
      
1159.     return if target.od_damage == 0
      
1160.     if target.absorbed                      # 吸収
      
1161.       fmt = target.actor? ? Vocab::ActorODDrain : Vocab::EnemyODDrain
      
1162.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1163.     elsif target.od_damage > 0              # ダメージ
      
1164.       fmt = target.actor? ? Vocab::ActorODLoss : Vocab::EnemyODLoss
      
1165.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1166.     else                                    # 回復
      
1167.       fmt = target.actor? ? Vocab::ActorODRecovery : Vocab::EnemyODRecovery
      
1168.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1169.       Sound.play_recovery
      
1170.     end
      
1171.     @message_window.add_instant_text(text)
      
1172.     wait(30)
      
1173.   end
      
1174. end
      

复制代码

问题如下：
1.能不能设置敌方不使用这个系统？
2.需要设置这么一个伤害技能（假定攻击获得的怒气是10），消耗X点MP产生20点怒气，应该怎么设置，使得使用这个技能之后获得的怒气是20而不是30？
3.需要设置这么一个伤害技能（假定攻击获得的怒气是10），消耗20点怒气，应该怎么设置，使得使用这个技能之后怒气消耗是20而不是10？
请各位赐教~

反斗奇彬

1. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
2. #_/    ◆ オーバードライブ - KGC_OverDrive ◆ VX ◆
   
3. #_/    ◇ Last update : 2009/11/01 ◇
   
4. #_/----------------------------------------------------------------------------
   
5. #_/  作成使用特殊气槽的技能（超必杀）
   
6. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
7. 
   
8. #==============================================================================
   
9. # ★  Customize项目 - Customize BEGIN ★
   
10. #==============================================================================
    
11. =begin
    
12. 特技的「备注 」栏加入 <オーバードライブ n> 。
    
13. n是特殊气槽的消费量。（请输入半角文字）
    
14. 写上了省略消费量的 <オーバードライブ>的话、消费１整格  (1000)。
    
15. 
    
16. 一个技能不能使用气槽的１整格 (1000) 以上。
    
17. （<オーバードライブ n> 的话、气槽在n以上的话可以）
    
18. <オーバードライブ n>可以使用 <over_drive n> 代替使用。
    
19. 数值之后加上 + 的话、会消费掉所有的气槽。
    
20. （如果消费量没满就不能用）
    
21. 这时，气槽量越多威力就越大
    
22. =end
    
23. module KGC
    
24. module OverDrive
    
25.   # ◆ 特殊气槽的最大值
    
26.   #  一般1000便可以了，可以自己微调。
    
27.   GAUGE_MAX = 1000
    
28.   # ◆ 特殊气槽的增加量
    
29.   #  若增加量高，则容易储满。
    
30.   #  如果指定负数，则代表特殊气槽减少
    
31.   #  「受到伤害」是、减少的HP乘上一定比例计算出来的增加量
    
32.   #  (500的话、等于HP减少了500，气槽增加值也为500)
    
33. #修改------------------------------------------------
    
34. GAIN_RATE = [
    
35.      10,  # 攻击
    
36.     150,  # 受到伤害
    
37.      20,  # 胜利
    
38.      10,  # 逃走
    
39.     100,  # 单独战斗
    
40.      10,  # 行动
    
41.     120,  # 濒死
    
42.      15,  # 防御
    
43.   ]  # ← 这个 ] 不可以删掉！
    
44. =begin
    
45.     GAIN_RATE = [
    
46.      80,  # 攻击
    
47.     500,  # 受到伤害
    
48.     200,  # 胜利
    
49.     100,  # 逃走
    
50.     160,  # 单独战斗
    
51.      40,  # 行动
    
52.     160,  # 濒死
    
53.      50,  # 防御
    
54.   ]  # ← 这个 ] 不可以删掉！
    
55. =end
    
56. #修改------------------------------------------------
    
57.   # ◆ 气槽的初始量
    
58.   DEFAULT_GAUGE_NUMBER = 1
    
59. 
    
60.   # ◆ 默认会增加气槽的类型
    
61.   #   0..攻击  1..受到伤害  2..胜利  3..逃走  4..单独战斗  5..行动
    
62.   #   6..濒死  7..防御
    
63. #修改------------------------------------------------
    
64.   DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6]        # 角色DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6]        # 角色
    
65.   DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]  # 敌人DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]  # 敌人
    
66. #修改------------------------------------------------
    
67.   # ◆ 气槽中的能量颜色
    
68.   #  数值  : 和 \C[n] 颜色一样。
    
69.   #  Color : 指定颜色。 ( Color.new(255, 128, 128) 等 )
    
70.   GAUGE_NORMAL_START_COLOR = 14  # 一般开始时的颜色
    
71.   GAUGE_NORMAL_END_COLOR   =  6  # 一般结束时的颜色
    
72.   GAUGE_MAX_START_COLOR    = 10  # 最大时的颜色
    
73.   GAUGE_MAX_END_COLOR      =  2  # 最大结束时的颜色
    
74. 
    
75.   # ◆ 特殊气槽设计为和一般气槽相同
    
76.   #  只在导入≪一般气槽能量表现≫时有效
    
77.   ENABLE_GENERIC_GAUGE = true
    
78.   # ◆ 气槽中的能量设定
    
79.   #  图片从 "Graphics/System" 中读取
    
80.   GAUGE_IMAGE     = "GaugeOD"     # 一般时的图片
    
81.   GAUGE_MAX_IMAGE = "GaugeODMax"  # 最大时的图片
    
82.   GAUGE_OFFSET    = [-23, -2]     # 位置修正 [x, y]
    
83.   GAUGE_LENGTH    = -4            # 长度修正
    
84.   GAUGE_SLOPE     = 30            # 倾斜度 (-89 ～ 89)
    
85. 
    
86.   # ◆ 气槽能量的Y坐标修正值
    
87.   #  未使用一般气槽时，才有效
    
88.   #  如果是 -8、HP/MP 和气槽在同一位置。
    
89.   GAUGE_OFFSET_Y = -8
    
90.   # ◆ 能量的数值表示
    
91.   #   0 .. 不表示  ※如果有两个能量珠以上时，不推荐这种
    
92.   #   1 .. 直接表示 (储存多少直接数字表示)
    
93.   #   2 .. 百分比 --> x%
    
94.   #   3 .. 百分比 (小数点后一位) --> x.x%
    
95.   #   4 .. 百分比 (小数点后两位) --> x.xx%
    
96.   #   5 .. 按能量珠表示
    
97.   GAUGE_VALUE_STYLE = 2
    
98.   # ◆ 能量储存值的表示文字的字体大小
    
99.   #  太大的话字体会模糊
    
100.   GAUGE_VALUE_FONT_SIZE = 14
     
101. 
     
102.   # ◆ 死亡（HP 0）时气槽能量归0
     
103.   EMPTY_ON_DEAD = true
     
104. 
     
105.   # ◆ 不显示气槽的角色
     
106.   # 通过输入角色ID归类为不显示气槽
     
107.   HIDE_GAUGE_ACTOR = []
     
108.   # ◆ 非战斗时不显示气槽
     
109.   HIDE_GAUGE_NOT_IN_BATTLE = false
     
110.   # ◆ 没有学习到超必杀技能时，不显示气槽
     
111.   HIDE_GAUGE_NO_OD_SKILLS  = true
     
112.   # ◆ 不显示气槽的场合，不能增加能量
     
113.   NOT_GAIN_GAUGE_HIDING    = true
     
114. 
     
115.   # ◆ 能量不足时不显示超必杀技能
     
116.   HIDE_SKILL_LACK_OF_GAUGE = false
     
117. 
     
118.   # ◆ 气槽能量的名字
     
119.   GAUGE_NAME = "气槽能量"
     
120.   # ◆ 使用影响气槽能量的道具时，显示的信息
     
121.   OD_GAIN_MESSAGE = {
     
122.     :drain_a   => "%s夺取了%s的能量！",  # 吸收: 角色
     
123.     :drain_e   => "%s的%s能量被夺取了！",    # 吸收: 敌人
     
124.     :loss_a    => "%s减少了%s的能量！",    # 减少: 角色
     
125.     :loss_e    => "%s减少了%s的能量！",    # 减少: 敌人
     
126.     :recover_a => "%s增加了%s的能量！",    # 增加: 角色
     
127.     :recover_e => "%s增加了%s的能量！",    # 增加: 敌人
     
128.   }
     
129. end
     
130. end
     
131. 
     
132. #==============================================================================
     
133. # ☆  Customize项目结束 - Customize END ☆
     
134. #==============================================================================
     
135. 
     
136. $imported = {} if $imported == nil
     
137. $imported["OverDrive"] = true
     
138. 
     
139. module KGC::OverDrive
     
140.   # ドライブタイプ
     
141.   module Type
     
142.     ATTACK  = 0  # 攻击
     
143.     DAMAGE  = 1  # 受到伤害
     
144.     VICTORY = 2  # 胜利
     
145.     ESCAPE  = 3  # 逃走
     
146.     ALONE   = 4  # 单独战斗
     
147.     ACTION  = 5  # 行动
     
148.     FATAL   = 6  # 濒死
     
149.     GUARD   = 7  # 防御
     
150.   end
     
151. 
     
152.   # 储存量表示
     
153.   module ValueStyle
     
154.     NONE         = 0  # 不显示
     
155.     IMMEDIATE    = 1  # 直接表示
     
156.     RATE         = 2  # 百分比
     
157.     RATE_DETAIL1 = 3  # 百分比 (小数点后一位)
     
158.     RATE_DETAIL2 = 4  # 百分比 (小数点后两位)
     
159.     NUMBER       = 5  # 按能量珠表示
     
160.   end
     
161. 
     
162.   module Regexp
     
163.     module UsableItem
     
164.       # 气槽能量增加
     
165.       OD_GAIN = /<(?:OD_GAIN|(?:OD|ドライブ)ゲージ増加)\s*([\+\-]?\d+)>/i
     
166.     end
     
167. 
     
168.     module Skill
     
169.       # 超必杀技能
     
170.       OVER_DRIVE = /<(?:OVER_DRIVE|オーバードライブ)\s*(\d+)?(\+)?>/i
     
171.       # 能量的增加量
     
172.       OD_GAIN_RATE =
     
173.         /<(?:OD_GAIN_RATE|(?:OD|ドライブ)ゲージ増加率)\s*(\d+)[%％]?>/i
     
174.     end
     
175.   end
     
176. end
     
177. 
     
178. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
179. 
     
180. #==============================================================================
     
181. # □ KGC::Commands
     
182. #==============================================================================
     
183. 
     
184. module KGC
     
185. module Commands
     
186.   module_function
     
187.   #--------------------------------------------------------------------------
     
188.   # ○ 角色的气槽能量的增减
     
189.   #     actor_id : 角色 ID (-1 : 表示全体)
     
190.   #     value    : 增加量 (可以是负数)
     
191.   #--------------------------------------------------------------------------
     
192.   def gain_actor_od_gauge(actor_id, value)
     
193.     if actor_id == -1
     
194.       # 操作生存中的我方角色全员的气槽能量
     
195.       $game_party.existing_members.each { |actor|
     
196.         next unless actor.can_gain_overdrive?
     
197.         actor.overdrive += value
     
198.       }
     
199.     else
     
200.       actor = $game_actors[actor_id]
     
201.       actor.overdrive += value if actor != nil && actor.exist?
     
202.     end
     
203.   end
     
204.   #--------------------------------------------------------------------------
     
205.   # ○ 敌人的气槽能量的增减
     
206.   #     enemy_index : 敌人 index (-1 : 表示全体)
     
207.   #     value       : 增加量 (可以是负数)
     
208.   #--------------------------------------------------------------------------
     
209.   def gain_enemy_od_gauge(enemy_index, value)
     
210.     if enemy_index == -1
     
211.       # 操作生存中的敌方角色全员的气槽能量
     
212.       $game_troop.existing_members.each { |enemy|
     
213.         enemy.overdrive += value
     
214.       }
     
215.     else
     
216.       enemy = $game_troop.members[enemy_index]
     
217.       enemy.overdrive += value if enemy != nil && enemy.exist?
     
218.     end
     
219.   end
     
220.   #--------------------------------------------------------------------------
     
221.   # ○ 角色的气槽能量的获得
     
222.   #     actor_id    : 角色 ID
     
223.   #     variable_id : 可以容纳的返回值的变量数 ID
     
224.   #--------------------------------------------------------------------------
     
225.   def get_actor_od_gauge(actor_id, variable_id = 0)
     
226.     actor = $game_actors[actor_id]
     
227.     n = (actor != nil ? actor.overdrive : 0)
     
228.     if variable_id > 0
     
229.       $game_variables[variable_id] = n
     
230.     end
     
231.     return n
     
232.   end
     
233.   #--------------------------------------------------------------------------
     
234.   # ○ 敌方的气槽能量的获得
     
235.   #     enemy_index : 敌人 index
     
236.   #     variable_id : 可以容纳的返回值的变量数 ID
     
237.   #--------------------------------------------------------------------------
     
238.   def get_enemy_od_gauge(enemy_index, variable_id = 0)
     
239.     enemy = $game_troop.members[enemy_index]
     
240.     n = (enemy != nil ? enemy.overdrive : 0)
     
241.     if variable_id > 0
     
242.       $game_variables[variable_id] = n
     
243.     end
     
244.     return n
     
245.   end
     
246.   #--------------------------------------------------------------------------
     
247.   # ○ 角色的气槽能量的能量珠数
     
248.   #     actor_id : 角色 ID (-1 : 表示全体)
     
249.   #     number   : 能量珠数
     
250.   #--------------------------------------------------------------------------
     
251.   def set_actor_od_gauge_number(actor_id, number)
     
252.     if actor_id == -1
     
253.       # 设定我方角色全体的能量珠数
     
254.       $game_party.members.each { |actor|
     
255.         actor.drive_gauge_number = number
     
256.       }
     
257.     else
     
258.       actor = $game_actors[actor_id]
     
259.       actor.drive_gauge_number = number if actor != nil
     
260.     end
     
261.   end
     
262.   #--------------------------------------------------------------------------
     
263.   # ○ 敌方的气槽能量的能量珠数
     
264.   #     enemy_index : 敌方 index (-1 : 表示全体)
     
265.   #     number   : 能量猪数
     
266.   #--------------------------------------------------------------------------
     
267.   def set_enemy_od_gauge_number(enemy_index, number)
     
268.     if enemy_index == -1
     
269.       # 设定生存中的敌方全体的能量珠数
     
270.       $game_troop.members.each { |enemy|
     
271.         enemy.drive_gauge_number = number
     
272.       }
     
273.     else
     
274.       enemy = $game_troop.members[enemy_index]
     
275.       enemy.drive_gauge_number = number if enemy != nil
     
276.     end
     
277.   end
     
278.   #--------------------------------------------------------------------------
     
279.   # ○ 角色的气槽能量变为最大时的设置
     
280.   #     actor_id : 角色 ID
     
281.   #--------------------------------------------------------------------------
     
282.   def actor_od_gauge_max?(actor_id)
     
283.     actor = $game_actors[actor_id]
     
284.     return false if actor == nil
     
285.     return actor.overdrive == actor.max_overdrive
     
286.   end
     
287.   #--------------------------------------------------------------------------
     
288.   # ○ 敌方的气槽能量变为最大时的设置
     
289.   #     enemy_index : 敌方 index
     
290.   #--------------------------------------------------------------------------
     
291.   def enemy_od_gauge_max?(enemy_index)
     
292.     enemy = $game_troop.members[enemy_index]
     
293.     return false if enemy == nil
     
294.     return enemy.overdrive == enemy.max_overdrive
     
295.   end
     
296.   #--------------------------------------------------------------------------
     
297.   # ○ 改变角色的能量槽类型
     
298.   #     actor_id : 角色 ID (-1 : 表示全体)
     
299.   #     types    : 能量槽的类型列表 (省略时 : 初始化)
     
300.   #--------------------------------------------------------------------------
     
301.   def set_actor_drive_type(actor_id, types = nil)
     
302.     if actor_id == -1
     
303.       # 改变角色全体的能量槽类型
     
304.       $game_party.members.each { |actor|
     
305.         actor.drive_type = types
     
306.       }
     
307.     else
     
308.       actor = $game_actors[actor_id]
     
309.       actor.drive_type = types if actor != nil
     
310.     end
     
311.   end
     
312.   #--------------------------------------------------------------------------
     
313.   # ○ 改变敌方的能量槽类型
     
314.   #     enemy_index : 敌方 index (-1 : 表示全体)
     
315.   #     types       : 能量槽的类型列表 (省略时 : 初始化)
     
316.   #--------------------------------------------------------------------------
     
317.   def set_enemy_drive_type(enemy_index, types = nil)
     
318.     if enemy_index == -1
     
319.       # 改变敌方全体的能量槽类型
     
320.       $game_troop.members.each { |enemy|
     
321.         enemy.drive_type = types
     
322.       }
     
323.     else
     
324.       enemy = $game_troop.members[enemy_index]
     
325.       enemy.drive_type = types if enemy != nil
     
326.     end
     
327.   end
     
328. end
     
329. end
     
330. 
     
331. class Game_Interpreter
     
332.   include KGC::Commands
     
333. end
     
334. 
     
335. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
336. 
     
337. #==============================================================================
     
338. # ■ RPG::UsableItem
     
339. #==============================================================================
     
340. 
     
341. class RPG::UsableItem < RPG::BaseItem
     
342.   #--------------------------------------------------------------------------
     
343.   # ○ 超必杀技能的生成
     
344.   #--------------------------------------------------------------------------
     
345.   def create_overdrive_cache
     
346.     @__od_gain = 0
     
347. 
     
348.     self.note.each_line { |line|
     
349.       case line
     
350.       when KGC::OverDrive::Regexp::UsableItem::OD_GAIN
     
351.         # 增加气槽能量
     
352.         @__od_gain = $1.to_i
     
353.       end
     
354.     }
     
355.   end
     
356.   #--------------------------------------------------------------------------
     
357.   # ○ 气槽能量的增加量
     
358.   #--------------------------------------------------------------------------
     
359.   def od_gain
     
360.     create_overdrive_cache if @__od_gain == nil
     
361.     return @__od_gain
     
362.   end
     
363.   #--------------------------------------------------------------------------
     
364.   # ○ 如果有超必杀技能的话
     
365.   #--------------------------------------------------------------------------
     
366.   def overdrive
     
367.     return false
     
368.   end
     
369.   alias overdrive? overdrive
     
370. end
     
371. 
     
372. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
373. 
     
374. #==============================================================================
     
375. # ■ RPG::Skill
     
376. #==============================================================================
     
377. 
     
378. class RPG::Skill < RPG::UsableItem
     
379.   #--------------------------------------------------------------------------
     
380.   # ○ 生成超必杀技能的内存
     
381.   #--------------------------------------------------------------------------
     
382.   def create_overdrive_cache
     
383.     super
     
384. 
     
385.     @__is_overdrive   = false
     
386.     @__od_cost        = KGC::OverDrive::GAUGE_MAX
     
387.     @__od_consume_all = false
     
388.     @__od_gain_rate   = 100
     
389. 
     
390.     self.note.each_line { |line|
     
391.       case line
     
392.       when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
     
393.         # オーバードライブ
     
394.         @__is_overdrive   = true
     
395.         @__od_cost        = $1.to_i if $1 != nil
     
396.         @__od_consume_all = ($2 != nil)
     
397.       when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
     
398.         # 能量增加率
     
399.         @__od_gain_rate = $1.to_i
     
400.       end
     
401.     }
     
402. 
     
403.     # 如果没有超必杀技能，则能量槽能量为0
     
404.     unless @__is_overdrive
     
405.       @__od_cost = 0
     
406.     end
     
407.   end
     
408.   #--------------------------------------------------------------------------
     
409.   # ○ 如果有超必杀技能
     
410.   #--------------------------------------------------------------------------
     
411.   def overdrive
     
412.     create_overdrive_cache if @__is_overdrive == nil
     
413.     return @__is_overdrive
     
414.   end
     
415.   alias overdrive? overdrive
     
416.   #--------------------------------------------------------------------------
     
417.   # ○ 气槽能量的消耗值
     
418.   #--------------------------------------------------------------------------
     
419.   def od_cost
     
420.     create_overdrive_cache if @__od_cost == nil
     
421.     return @__od_cost
     
422.   end
     
423.   #--------------------------------------------------------------------------
     
424.   # ○ 气槽能量全部消耗掉
     
425.   #--------------------------------------------------------------------------
     
426.   def od_consume_all
     
427.     create_overdrive_cache if @__od_consume_all == nil
     
428.     return @__od_consume_all
     
429.   end
     
430.   alias od_consume_all? od_consume_all
     
431.   #--------------------------------------------------------------------------
     
432.   # ○ 气槽能量的增加率
     
433.   #--------------------------------------------------------------------------
     
434.   def od_gain_rate
     
435.     create_overdrive_cache if @__od_gain_rate == nil
     
436.     return @__od_gain_rate
     
437.   end
     
438. end
     
439. 
     
440. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
441. 
     
442. #==============================================================================
     
443. # ■ Vocab
     
444. #==============================================================================
     
445. 
     
446. module Vocab
     
447.   # 气槽能量名
     
448.   def self.overdrive
     
449.     return KGC::OverDrive::GAUGE_NAME
     
450.   end
     
451. 
     
452.   # 角色这边的显示信息
     
453.   ActorODDrain    = KGC::OverDrive::OD_GAIN_MESSAGE[:drain_a]
     
454.   ActorODLoss     = KGC::OverDrive::OD_GAIN_MESSAGE[:loss_a]
     
455.   ActorODRecovery = KGC::OverDrive::OD_GAIN_MESSAGE[:recover_a]
     
456. 
     
457.   # 敌人那边的显示信息
     
458.   EnemyODDrain    = KGC::OverDrive::OD_GAIN_MESSAGE[:drain_e]
     
459.   EnemyODLoss     = KGC::OverDrive::OD_GAIN_MESSAGE[:loss_e]
     
460.   EnemyODRecovery = KGC::OverDrive::OD_GAIN_MESSAGE[:recover_e]
     
461. end
     
462. 
     
463. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
464. 
     
465. #==============================================================================
     
466. # ■ Game_Battler
     
467. #==============================================================================
     
468. 
     
469. class Game_Battler
     
470.   #--------------------------------------------------------------------------
     
471.   # ● 公开的公有变量
     
472.   #--------------------------------------------------------------------------
     
473.   attr_writer   :drive_type               # 气槽类型
     
474.   attr_reader   :od_damage                # 行动结果: 气槽伤害
     
475.   #--------------------------------------------------------------------------
     
476.   # ● 清除保存行动效果的变量
     
477.   #--------------------------------------------------------------------------
     
478.   alias clear_action_results_KGC_OverDrive clear_action_results
     
479.   def clear_action_results
     
480.     clear_action_results_KGC_OverDrive
     
481. 
     
482.     @od_damage = 0
     
483.   end
     
484.   #--------------------------------------------------------------------------
     
485.   # ○ 获得气槽能量
     
486.   #--------------------------------------------------------------------------
     
487.   def overdrive
     
488.     @overdrive = 0 if @overdrive == nil
     
489.     return @overdrive
     
490.   end
     
491.   #--------------------------------------------------------------------------
     
492.   # ○ 操作气槽能量
     
493.   #--------------------------------------------------------------------------
     
494.   def overdrive=(value)
     
495.     @overdrive = [[value, max_overdrive].min, 0].max
     
496.   end
     
497.   #--------------------------------------------------------------------------
     
498.   # ○ 获得气槽能量的最大值
     
499.   #--------------------------------------------------------------------------
     
500.   def max_overdrive
     
501.     return KGC::OverDrive::GAUGE_MAX * drive_gauge_number
     
502.   end
     
503.   #--------------------------------------------------------------------------
     
504.   # ○ 能量为MAX时的判定
     
505.   #--------------------------------------------------------------------------
     
506.   def overdrive_max?
     
507.     return (overdrive == max_overdrive)
     
508.   end
     
509.   #--------------------------------------------------------------------------
     
510.   # ○ 能量珠数的取得
     
511.   #--------------------------------------------------------------------------
     
512.   def drive_gauge_number
     
513.     if @drive_gauge_number == nil
     
514.       @drive_gauge_number = KGC::OverDrive::DEFAULT_GAUGE_NUMBER
     
515.     end
     
516.     return @drive_gauge_number
     
517.   end
     
518.   #--------------------------------------------------------------------------
     
519.   # ○ 操作能量珠数
     
520.   #--------------------------------------------------------------------------
     
521.   def drive_gauge_number=(value)
     
522.     @drive_gauge_number = [value, 1].max
     
523.   end
     
524.   #--------------------------------------------------------------------------
     
525.   # ○ 气槽类型的取得
     
526.   #--------------------------------------------------------------------------
     
527.   def drive_type
     
528.     return []
     
529.   end
     
530.   #--------------------------------------------------------------------------
     
531.   # ○ 超必杀是否学习到的判断
     
532.   #--------------------------------------------------------------------------
     
533.   def overdrive_skill_learned?
     
534.     return true
     
535.   end
     
536.   #--------------------------------------------------------------------------
     
537.   # ○ 气槽是否表示的判断
     
538.   #--------------------------------------------------------------------------
     
539.   def od_gauge_visible?
     
540.     return false
     
541.   end
     
542.   #--------------------------------------------------------------------------
     
543.   # ○ 能量可否增加的判断
     
544.   #--------------------------------------------------------------------------
     
545.   def can_gain_overdrive?
     
546.     return true
     
547.   end
     
548.   #--------------------------------------------------------------------------
     
549.   # ○ 攻撃時増加判定
     
550.   #--------------------------------------------------------------------------
     
551.   def drive_attack?
     
552.     return drive_type.include?(KGC::OverDrive::Type::ATTACK)
     
553.   end
     
554.   #--------------------------------------------------------------------------
     
555.   # ○ 受到伤害时的增加判断
     
556.   #--------------------------------------------------------------------------
     
557.   def drive_damage?
     
558.     return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
     
559.   end
     
560.   #--------------------------------------------------------------------------
     
561.   # ○ 胜利时的增加判断
     
562.   #--------------------------------------------------------------------------
     
563.   def drive_victory?
     
564.     return drive_type.include?(KGC::OverDrive::Type::VICTORY)
     
565.   end
     
566.   #--------------------------------------------------------------------------
     
567.   # ○ 逃走时的增加判断
     
568.   #--------------------------------------------------------------------------
     
569.   def drive_escape?
     
570.     return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
     
571.   end
     
572.   #--------------------------------------------------------------------------
     
573.   # ○ 单独战斗时的增加判断
     
574.   #--------------------------------------------------------------------------
     
575.   def drive_alone?
     
576.     return drive_type.include?(KGC::OverDrive::Type::ALONE)
     
577.   end
     
578.   #--------------------------------------------------------------------------
     
579.   # ○ 行动时的增加判断
     
580.   #--------------------------------------------------------------------------
     
581.   def drive_action?
     
582.     return drive_type.include?(KGC::OverDrive::Type::ACTION)
     
583.   end
     
584.   #--------------------------------------------------------------------------
     
585.   # ○ 濒死的增加判断
     
586.   #--------------------------------------------------------------------------
     
587.   def drive_fatal?
     
588.     return drive_type.include?(KGC::OverDrive::Type::FATAL)
     
589.   end
     
590.   #--------------------------------------------------------------------------
     
591.   # ○ 防御时的增加判断
     
592.   #--------------------------------------------------------------------------
     
593.   def drive_guard?
     
594.     return drive_type.include?(KGC::OverDrive::Type::GUARD)
     
595.   end
     
596.   #--------------------------------------------------------------------------
     
597.   # ● 状态附加
     
598.   #     state_id : 状态 ID
     
599.   #--------------------------------------------------------------------------
     
600.   alias add_state_KGC_OverDrive add_state
     
601.   def add_state(state_id)
     
602.     add_state_KGC_OverDrive(state_id)
     
603. 
     
604.     reset_overdrive_on_dead if dead?
     
605.   end
     
606.   #--------------------------------------------------------------------------
     
607.   # ○ 计算技能消耗的能量
     
608.   #     skill : 技能
     
609.   #--------------------------------------------------------------------------
     
610.   def calc_od_cost(skill)
     
611.     return 0 unless skill.is_a?(RPG::Skill)
     
612. 
     
613.     return skill.od_cost
     
614.   end
     
615.   #--------------------------------------------------------------------------
     
616.   # ● 技能是否可以使用的判断
     
617.   #     skill : 技能
     
618.   #--------------------------------------------------------------------------
     
619.   alias skill_can_use_KGC_OverDrive? skill_can_use?
     
620.   def skill_can_use?(skill)
     
621.     return false unless skill_can_use_KGC_OverDrive?(skill)
     
622. 
     
623.     return false if calc_od_cost(skill) > overdrive
     
624.     return true
     
625.   end
     
626.   #--------------------------------------------------------------------------
     
627.   # ● 基于技能或物品的伤害判定
     
628.   #     user : 技能或物品的使用者
     
629.   #     obj  : 技能或物品
     
630.   #    结果将代入 @hp_damage 或 @mp_damage 。
     
631.   #--------------------------------------------------------------------------
     
632.   alias make_obj_damage_value_KGC_OverDrive make_obj_damage_value
     
633.   def make_obj_damage_value(user, obj)
     
634.     make_obj_damage_value_KGC_OverDrive(user, obj)
     
635. 
     
636.     apply_od_consume_all_for_damage(user, obj)
     
637.   end
     
638.   #--------------------------------------------------------------------------
     
639.   # ○ 适用于气槽能量全消耗时
     
640.   #     user : 技能或物品的使用者
     
641.   #     obj  : 技能或物品
     
642.   #    结果将代入 @hp_damage 或 @mp_damage 。
     
643.   #--------------------------------------------------------------------------
     
644.   def apply_od_consume_all_for_damage(user, obj)
     
645.     return unless obj.is_a?(RPG::Skill)
     
646.     return unless obj.overdrive? && obj.od_consume_all?
     
647. 
     
648.     # 剩余能量消耗的强化 (例: 最低消耗量为 1000 时消耗 1200 的话效果是 1.2 倍)
     
649.     rate = [user.overdrive * 1000 / obj.od_cost, 1000].max
     
650.     @hp_damage = @hp_damage * rate / 1000
     
651.     @mp_damage = @mp_damage * rate / 1000
     
652.   end
     
653.   #--------------------------------------------------------------------------
     
654.   # ● 受到伤害时的反映
     
655.   #     user : 技能或物品的使用者
     
656.   #    若要使用此部分，请先设置 @hp_damage、@mp_damage、@absorbed 。
     
657.   #--------------------------------------------------------------------------
     
658.   alias execute_damage_KGC_OverDrive execute_damage
     
659.   def execute_damage(user)
     
660.     execute_damage_KGC_OverDrive(user)
     
661. 
     
662.     increase_overdrive(user)
     
663.     increase_overdrive_by_item(user)
     
664.   end
     
665.   #--------------------------------------------------------------------------
     
666.   # ○ 死亡时气槽能量的初始化
     
667.   #--------------------------------------------------------------------------
     
668.   def reset_overdrive_on_dead
     
669.     return unless KGC::OverDrive::EMPTY_ON_DEAD
     
670. 
     
671.     self.overdrive = 0
     
672.   end
     
673.   #--------------------------------------------------------------------------
     
674.   # ○ 气槽能量的增加处理
     
675.   #     attacker : 攻击者
     
676.   #--------------------------------------------------------------------------
     
677.   def increase_overdrive(attacker = nil)
     
678.     return unless attacker.is_a?(Game_Battler)  # 攻击者非战场单位
     
679.     return unless actor? ^ attacker.actor?      # 攻击者和防御者在同一阵型
     
680.     return if hp_damage == 0 && mp_damage == 0  # 不受到伤害
     
681. 
     
682.     increase_attacker_overdrive(attacker)
     
683.     increase_defender_overdrive(attacker)
     
684.     reset_overdrive_on_dead if dead?
     
685.   end
     
686.   #--------------------------------------------------------------------------
     
687.   # ○ 攻击方的气槽能量处理
     
688.   #     attacker : 攻击者
     
689.   #--------------------------------------------------------------------------
     
690.   def increase_attacker_overdrive(attacker)
     
691.     return unless can_gain_overdrive?
     
692.     return unless attacker.drive_attack?  # ドライブタイプ「攻撃」なし
     
693. 
     
694.     od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
     
695.     if attacker.action.kind == 1
     
696.       rate = attacker.action.skill.od_gain_rate  # スキルの倍率を適用
     
697.       od_gain = od_gain * rate / 100
     
698.       if rate > 0
     
699.         od_gain = [od_gain, 1].max
     
700.       elsif rate < 0
     
701.         od_gain = [od_gain, -1].min
     
702.       end
     
703.     end
     
704.     attacker.overdrive += od_gain
     
705.   end
     
706.   #--------------------------------------------------------------------------
     
707.   # ○ 防御方的气槽能量处理
     
708.   #     attacker : 攻击者
     
709.   #--------------------------------------------------------------------------
     
710.   def increase_defender_overdrive(attacker)
     
711.     return unless can_gain_overdrive?
     
712.     return unless self.drive_damage?  # 气槽类型不受到伤害
     
713. 
     
714.     rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
     
715.     od_gain = 0
     
716.     od_gain += hp_damage * rate / maxhp if hp_damage > 0
     
717.     od_gain += mp_damage * rate / maxmp if mp_damage > 0 && maxmp > 0
     
718.     if rate > 0
     
719.       od_gain = [od_gain, 1].max
     
720.     elsif rate < 0
     
721.       od_gain = [od_gain, -1].min
     
722.     end
     
723.     self.overdrive += od_gain
     
724.   end
     
725.   #--------------------------------------------------------------------------
     
726.   # ○ 使用物品增加气槽时的处理
     
727.   #     user : 使用者
     
728.   #--------------------------------------------------------------------------
     
729.   def increase_overdrive_by_item(user = nil)
     
730.     return unless user.is_a?(Game_Battler)
     
731.     return unless can_gain_overdrive?
     
732. 
     
733.     if user.action.skill?
     
734.       obj = user.action.skill
     
735.     elsif user.action.item?
     
736.       obj = user.action.item
     
737.     else
     
738.       return
     
739.     end
     
740.     @od_damage = -obj.od_gain
     
741.     self.overdrive -= @od_damage
     
742.   end
     
743.   #--------------------------------------------------------------------------
     
744.   # ● 适用于技能效果
     
745.   #     user  : 技能的使用者
     
746.   #     skill : 技能
     
747.   #--------------------------------------------------------------------------
     
748.   alias skill_effect_KGC_OverDrive skill_effect
     
749.   def skill_effect(user, skill)
     
750.     skill_effect_KGC_OverDrive(user, skill)
     
751. 
     
752.     # 无视物品或技能对气槽能量的影响
     
753.     if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
     
754.       return
     
755.     end
     
756.   end
     
757. end
     
758. 
     
759. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
760. 
     
761. #==============================================================================
     
762. # ■ Game_Actor
     
763. #==============================================================================
     
764. 
     
765. class Game_Actor < Game_Battler
     
766.   #--------------------------------------------------------------------------
     
767.   # ● 设置
     
768.   #     actor_id : 角色 ID
     
769.   #--------------------------------------------------------------------------
     
770.   alias setup_KGC_OverDrive setup
     
771.   def setup(actor_id)
     
772.     setup_KGC_OverDrive(actor_id)
     
773. 
     
774.     @overdrive  = 0
     
775.     @drive_type = nil
     
776.   end
     
777.   #--------------------------------------------------------------------------
     
778.   # ○ 气槽类型的获得
     
779.   #--------------------------------------------------------------------------
     
780.   def drive_type
     
781.     unless @drive_type.is_a?(Array)
     
782.       return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
     
783.     end
     
784.     return @drive_type
     
785.   end
     
786.   #--------------------------------------------------------------------------
     
787.   # ○ 判断是否学习到超必杀技能
     
788.   #--------------------------------------------------------------------------
     
789.   def overdrive_skill_learned?
     
790.     result = false
     
791.     # 解除一时的战斗FLAG
     
792.     last_in_battle = $game_temp.in_battle
     
793.     $game_temp.in_battle = false
     
794. 
     
795.     self.skills.each { |skill|
     
796.       if skill.overdrive?
     
797.         result = true
     
798.         break
     
799.       end
     
800.     }
     
801.     $game_temp.in_battle = last_in_battle
     
802.     return result
     
803.   end
     
804.   #--------------------------------------------------------------------------
     
805.   # ○ 判断是否可以增加气槽能量
     
806.   #--------------------------------------------------------------------------
     
807.   def can_gain_overdrive?
     
808.     if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
     
809.       # 不表示
     
810.       return false unless od_gauge_visible_l?
     
811.     end
     
812.     if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
     
813.       # 没有学到超必杀
     
814.       return false unless overdrive_skill_learned?
     
815.     end
     
816. 
     
817.     return true
     
818.   end
     
819.   #--------------------------------------------------------------------------
     
820.   # ○ 气槽能量的表示判断
     
821.   #--------------------------------------------------------------------------
     
822.   def od_gauge_visible?
     
823.     return false unless od_gauge_visible_l?
     
824.     return false unless can_gain_overdrive?
     
825. 
     
826.     return true
     
827.   end
     
828.   #--------------------------------------------------------------------------
     
829.   # ○ 气槽能量的表示判断 (简易版)
     
830.   #--------------------------------------------------------------------------
     
831.   def od_gauge_visible_l?
     
832.     # 战斗中不表示
     
833.     if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
     
834.       return false
     
835.     end
     
836.     # 完全不表示
     
837.     return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
     
838. 
     
839.     return true
     
840.   end
     
841. end
     
842. 
     
843. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
844. 
     
845. #==============================================================================
     
846. # ■ Game_Enemy
     
847. #==============================================================================
     
848. 
     
849. class Game_Enemy < Game_Battler
     
850.   #--------------------------------------------------------------------------
     
851.   # ● 对象初始化
     
852.   #     index    : 敌方团体的编号
     
853.   #     enemy_id : 敌方编号 ID
     
854.   #--------------------------------------------------------------------------
     
855.   alias initialize_KGC_OverDrive initialize
     
856.   def initialize(index, enemy_id)
     
857.     initialize_KGC_OverDrive(index, enemy_id)
     
858. 
     
859.     @overdrive  = 0
     
860.     @drive_type = nil
     
861.   end
     
862.   #--------------------------------------------------------------------------
     
863.   # ○ 气槽类型的取得
     
864.   #--------------------------------------------------------------------------
     
865.   def drive_type
     
866.     unless @drive_type.is_a?(Array)
     
867.       return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
     
868.     end
     
869.     return @drive_type
     
870.   end
     
871. end
     
872. 
     
873. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
874. 
     
875. #==============================================================================
     
876. # ■ Window_Base
     
877. #==============================================================================
     
878. 
     
879. class Window_Base < Window
     
880.   #--------------------------------------------------------------------------
     
881.   # ○ 气槽能量的一般颜色 1 的获得
     
882.   #--------------------------------------------------------------------------
     
883.   def od_gauge_normal_color1
     
884.     color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
     
885.     return (color.is_a?(Integer) ? text_color(color) : color)
     
886.   end
     
887.   #--------------------------------------------------------------------------
     
888.   # ○ 气槽能量的一般颜色 2 的获得
     
889.   #--------------------------------------------------------------------------
     
890.   def od_gauge_normal_color2
     
891.     color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
     
892.     return (color.is_a?(Integer) ? text_color(color) : color)
     
893.   end
     
894.   #--------------------------------------------------------------------------
     
895.   # ○ 气槽能量的最大颜色 1 的获得
     
896.   #--------------------------------------------------------------------------
     
897.   def od_gauge_max_color1
     
898.     color = KGC::OverDrive::GAUGE_MAX_START_COLOR
     
899.     return (color.is_a?(Integer) ? text_color(color) : color)
     
900.   end
     
901.   #--------------------------------------------------------------------------
     
902.   # ○ 气槽能量的最大颜色 2 的获得
     
903.   #--------------------------------------------------------------------------
     
904.   def od_gauge_max_color2
     
905.     color = KGC::OverDrive::GAUGE_MAX_END_COLOR
     
906.     return (color.is_a?(Integer) ? text_color(color) : color)
     
907.   end
     
908.   #--------------------------------------------------------------------------
     
909.   # ● 名字的表示
     
910.   #     actor : 角色
     
911.   #     x     : X坐标
     
912.   #     y     : Y坐标
     
913.   #--------------------------------------------------------------------------
     
914.   alias draw_actor_name_KGC_OverDrive draw_actor_name
     
915.   def draw_actor_name(actor, x, y)
     
916.     draw_actor_od_gauge(actor, x, y, 108)
     
917. 
     
918.     draw_actor_name_KGC_OverDrive(actor, x, y)
     
919.   end
     
920.   #--------------------------------------------------------------------------
     
921.   # ○ 气槽能量的表示
     
922.   #     actor : 角色
     
923.   #     x     : X坐标
     
924.   #     y     : Y坐标
     
925.   #     width : 宽度
     
926.   #--------------------------------------------------------------------------
     
927.   def draw_actor_od_gauge(actor, x, y, width = 120)
     
928.     return unless actor.od_gauge_visible?
     
929. 
     
930.     n = actor.overdrive % KGC::OverDrive::GAUGE_MAX
     
931.     n = KGC::OverDrive::GAUGE_MAX if actor.overdrive_max?
     
932. 
     
933.     if KGC::OverDrive::ENABLE_GENERIC_GAUGE && $imported["GenericGauge"]
     
934.       # 汎用ゲージ
     
935.       file = (actor.overdrive_max? ?
     
936.         KGC::OverDrive::GAUGE_MAX_IMAGE : KGC::OverDrive::GAUGE_IMAGE)
     
937.       draw_gauge(file,
     
938.         x, y, width, n, KGC::OverDrive::GAUGE_MAX,
     
939.         KGC::OverDrive::GAUGE_OFFSET,
     
940.         KGC::OverDrive::GAUGE_LENGTH,
     
941.         KGC::OverDrive::GAUGE_SLOPE)
     
942.     else
     
943.       # デフォルトゲージ
     
944.       gw = width * n / KGC::OverDrive::GAUGE_MAX
     
945.       gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
     
946.       gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
     
947.       self.contents.fill_rect(x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y,
     
948.         width, 6, gauge_back_color)
     
949.       self.contents.gradient_fill_rect(
     
950.         x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y, gw, 6, gc1, gc2)
     
951.     end
     
952. 
     
953.     draw_actor_od_gauge_value(actor, x, y, width)
     
954.   end
     
955.   #--------------------------------------------------------------------------
     
956.   # ○ 气槽能量的储存量的表示
     
957.   #     actor : 角色
     
958.   #     x     : X坐标
     
959.   #     y     : Y坐标
     
960.   #     width : 宽度
     
961.   #--------------------------------------------------------------------------
     
962.   def draw_actor_od_gauge_value(actor, x, y, width = 120)
     
963.     text = ""
     
964.     value = actor.overdrive * 100.0 / KGC::OverDrive::GAUGE_MAX
     
965.     case KGC::OverDrive::GAUGE_VALUE_STYLE
     
966.     when KGC::OverDrive::ValueStyle::IMMEDIATE
     
967.       text = actor.overdrive.to_s
     
968.     when KGC::OverDrive::ValueStyle::RATE
     
969.       text = sprintf("%d%%", actor.overdrive * 100 / KGC::OverDrive::GAUGE_MAX)
     
970.     when KGC::OverDrive::ValueStyle::RATE_DETAIL1
     
971.       text = sprintf("%0.1f%%", value)
     
972.     when KGC::OverDrive::ValueStyle::RATE_DETAIL2
     
973.       text = sprintf("%0.2f%%", value)
     
974.     when KGC::OverDrive::ValueStyle::NUMBER
     
975.       text = "#{actor.overdrive / KGC::OverDrive::GAUGE_MAX}"
     
976.     else
     
977.       return
     
978.     end
     
979. 
     
980.     last_font_size = self.contents.font.size
     
981.     new_font_size  = KGC::OverDrive::GAUGE_VALUE_FONT_SIZE
     
982.     self.contents.font.size = new_font_size
     
983.     self.contents.draw_text(
     
984.       x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y - new_font_size / 2,
     
985.       width, new_font_size, text, 2)
     
986.     self.contents.font.size = last_font_size
     
987.   end
     
988. end
     
989. 
     
990. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
991. 
     
992. #==============================================================================
     
993. # ■ Window_Skill
     
994. #==============================================================================
     
995. 
     
996. if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
     
997. 
     
998. class Window_Skill < Window_Selectable
     
999.   #--------------------------------------------------------------------------
     
1000.   # ○ 如果含有技能的列表？
      
1001.   #     skill : 技能
      
1002.   #--------------------------------------------------------------------------
      
1003.   unless $@
      
1004.     alias include_KGC_OverDrive? include? if method_defined?(:include?)
      
1005.   end
      
1006.   def include?(skill)
      
1007.     return false if skill == nil
      
1008. 
      
1009.     if defined?(include_KGC_OverDrive?)
      
1010.       return false unless include_KGC_OverDrive?(skill)
      
1011.     end
      
1012. 
      
1013.     if skill.overdrive?
      
1014.       return (@actor.calc_od_cost(skill) <= @actor.overdrive)
      
1015.     else
      
1016.       return true
      
1017.     end
      
1018.   end
      
1019. 
      
1020. if method_defined?(:include_KGC_OverDrive?)
      
1021.   #--------------------------------------------------------------------------
      
1022.   # ● 刷新
      
1023.   #--------------------------------------------------------------------------
      
1024.   def refresh
      
1025.     @data = []
      
1026.     for skill in @actor.skills
      
1027.       next unless include?(skill)
      
1028.       @data.push(skill)
      
1029.       if skill.id == @actor.last_skill_id
      
1030.         self.index = @data.size - 1
      
1031.       end
      
1032.     end
      
1033.     @item_max = @data.size
      
1034.     create_contents
      
1035.     for i in 0...@item_max
      
1036.       draw_item(i)
      
1037.     end
      
1038.   end
      
1039. end
      
1040. 
      
1041. end  # <-- class
      
1042. end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
      
1043. 
      
1044. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
      
1045. 
      
1046. #==============================================================================
      
1047. # ■ Scene_Skill
      
1048. #==============================================================================
      
1049. 
      
1050. class Scene_Skill < Scene_Base
      
1051.   #--------------------------------------------------------------------------
      
1052.   # ● 使用技能 (使用效果适用于非我方人物)
      
1053.   #--------------------------------------------------------------------------
      
1054.   alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
      
1055.   def use_skill_nontarget
      
1056.     consume_od_gauge
      
1057. 
      
1058.     use_skill_nontarget_KGC_OverDrive
      
1059.   end
      
1060.   #--------------------------------------------------------------------------
      
1061.   # ○ 使用技能时气槽能量的消耗
      
1062.   #--------------------------------------------------------------------------
      
1063.   def consume_od_gauge
      
1064.     if @skill.od_consume_all?
      
1065.       @actor.overdrive = 0
      
1066.     else
      
1067.       @actor.overdrive -= @actor.calc_od_cost(@skill)
      
1068.     end
      
1069.   end
      
1070. end
      
1071. 
      
1072. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
      
1073. 
      
1074. #==============================================================================
      
1075. # ■ Scene_Battle
      
1076. #==============================================================================
      
1077. 
      
1078. class Scene_Battle < Scene_Base
      
1079.   #--------------------------------------------------------------------------
      
1080.   # ● 战斗结束
      
1081.   #     result : 结果 (0:胜利 1:逃走 2:失败)
      
1082.   #--------------------------------------------------------------------------
      
1083.   alias battle_end_KGC_OverDrive battle_end
      
1084.   def battle_end(result)
      
1085.     increase_overdrive_on_battle_end(result)
      
1086. 
      
1087.     battle_end_KGC_OverDrive(result)
      
1088.   end
      
1089.   #--------------------------------------------------------------------------
      
1090.   # ○ 战斗结束时气槽能量的增加处理
      
1091.   #     result : 结果 (0:胜利 1:逃走 2:失败)
      
1092.   #--------------------------------------------------------------------------
      
1093.   def increase_overdrive_on_battle_end(result)
      
1094.     case result
      
1095.     when 0  # 胜利
      
1096.       od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
      
1097.       $game_party.existing_members.each { |actor|
      
1098.         actor.overdrive += od_gain if actor.drive_victory?
      
1099.       }
      
1100.     when 1  # 逃走
      
1101.       od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
      
1102.       $game_party.existing_members.each { |actor|
      
1103.         actor.overdrive += od_gain if actor.drive_escape?
      
1104.       }
      
1105.     end
      
1106.   end
      
1107.   #--------------------------------------------------------------------------
      
1108.   # ● 战斗行动的实行
      
1109.   #--------------------------------------------------------------------------
      
1110.   alias execute_action_KGC_OverDrive execute_action
      
1111.   def execute_action
      
1112.     increase_overdrive_on_action
      
1113. 
      
1114.     execute_action_KGC_OverDrive
      
1115.   end
      
1116.   #--------------------------------------------------------------------------
      
1117.   # ○ 行动时的气槽能量的增加处理
      
1118.   #--------------------------------------------------------------------------
      
1119.   def increase_overdrive_on_action
      
1120.     battler = @active_battler
      
1121.     od_gain = 0
      
1122.     unit = (battler.actor? ? $game_party : $game_troop)
      
1123. 
      
1124.     # 单独战斗
      
1125.     if battler.drive_alone? && unit.existing_members.size == 1
      
1126.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
      
1127.     end
      
1128.     # 行动
      
1129.     if battler.drive_action?
      
1130.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
      
1131.     end
      
1132.     # 濒死
      
1133.     if battler.drive_fatal? && battler.hp < battler.maxhp / 4
      
1134.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
      
1135.     end
      
1136.     # 防御
      
1137.     if battler.drive_guard? && battler.action.kind == 0 &&
      
1138.         battler.action.basic == 1
      
1139.       od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD]
      
1140.     end
      
1141.     battler.overdrive += od_gain
      
1142.   end
      
1143.   #--------------------------------------------------------------------------
      
1144.   # ● 战斗行动的实行：技能
      
1145.   #--------------------------------------------------------------------------
      
1146.   alias execute_action_skill_KGC_OverDrive execute_action_skill
      
1147.   def execute_action_skill
      
1148.     execute_action_skill_KGC_OverDrive
      
1149. 
      
1150.     consume_od_gauge
      
1151.   end
      
1152.   #--------------------------------------------------------------------------
      
1153.   # ○ 技能使用时的气槽能量的增加处理
      
1154.   #--------------------------------------------------------------------------
      
1155.   def consume_od_gauge
      
1156.     return unless @active_battler.action.skill?
      
1157. 
      
1158.     skill = @active_battler.action.skill
      
1159.     if skill.od_consume_all?
      
1160.       @active_battler.overdrive = 0
      
1161.     else
      
1162.       @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
      
1163.     end
      
1164.   end
      
1165.   #--------------------------------------------------------------------------
      
1166.   # ● 伤害的表示
      
1167.   #     target : 目标
      
1168.   #     obj    : 技能或物品
      
1169.   #--------------------------------------------------------------------------
      
1170.   alias display_damage_KGC_OverDrive display_damage
      
1171.   def display_damage(target, obj = nil)
      
1172.     display_damage_KGC_OverDrive(target, obj)
      
1173. 
      
1174.     return if target.missed || target.evaded
      
1175.     display_od_damage(target, obj)
      
1176.   end
      
1177.   #--------------------------------------------------------------------------
      
1178.   # ○ 超必杀的伤害表示
      
1179.   #     target : 目标
      
1180.   #     obj    : 技能或物品
      
1181.   #--------------------------------------------------------------------------
      
1182.   def display_od_damage(target, obj = nil)
      
1183.     return if target.dead?
      
1184.     return if target.od_damage == 0
      
1185.     if target.absorbed                      # 吸收
      
1186.       fmt = target.actor? ? Vocab::ActorODDrain : Vocab::EnemyODDrain
      
1187.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1188.     elsif target.od_damage > 0              # 受到伤害
      
1189.       fmt = target.actor? ? Vocab::ActorODLoss : Vocab::EnemyODLoss
      
1190.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1191.     else                                    # 回复
      
1192.       fmt = target.actor? ? Vocab::ActorODRecovery : Vocab::EnemyODRecovery
      
1193.       text = sprintf(fmt, target.name, Vocab::overdrive)
      
1194.       Sound.play_recovery
      
1195.     end
      
1196.     @message_window.add_instant_text(text)
      
1197.     wait(30)
      
1198.   end
      
1199. end

复制代码