请教关于KCG独立战斗指令脚本的使用问题

赛托希梅亚

这个脚本好像可以加入新的指令，但我看不懂，请问该如何添加新的战斗指令呢？应该在哪里设置呢？

1. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
2. #_/    ◆ 個別戦闘コマンド - KGC_SeparationCommand ◆ VX ◆
   
3. #_/    ◇ Last update : 2008/04/01 ◇
   
4. #_/----------------------------------------------------------------------------
   
5. #_/  キャラ固有のコマンドを作成する機能を追加します。
   
6. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
   
7. 
   
8. #==============================================================================
   
9. # ★ カスタマイズ項目 - Customize ★
   
10. #==============================================================================
    
11. 
    
12. module KGC
    
13. module SeparationCommand
    
14.   # ◆ デフォルトのコマンド配置
    
15.   #  戦闘時に表示するコマンドを「表示したい順」に記述してください。
    
16.   #  使用しないコマンドは書かなくても構いません。
    
17.   #  ※ 同じコマンドを２箇所以上に配置するとバグります。
    
18.   #   ** 対応表 **
    
19.   #  0..攻撃  1..スキル  2..防御  3..アイテム  4..固有コマンド
    
20.   DEFAULT_COMMANDS = [0, 4, 1, 2, 3]
    
21. 
    
22.   # ◆ アクター別のコマンド配置
    
23.   ACTOR_COMMANDS = []  # ← これは消さないこと！
    
24.   # ここから下に、アクターごとのコマンド配置を
    
25.   #   ACTOR_COMMANDS[アクター ID] = [コマンド]
    
26.   # という形式で設定します。
    
27.   # 対応表は DEFAULT_COMMANDS と同じです。
    
28.   #   <例> アクターID:2 の「スキル」を消す
    
29.   ACTOR_COMMANDS[2] = DEFAULT_COMMANDS - [1]
    
30.   #  ↑ ACTOR_COMMANDS[2] = [0, 4, 2, 3] でもOK。
    
31. end
    
32. end
    
33. 
    
34. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
    
35. 
    
36. $imported = {} if $imported == nil
    
37. $imported["SeparationCommand"] = true
    
38. 
    
39. module KGC::SeparationCommand
    
40.   # 正規表現
    
41.   module Regexp
    
42.     # 固有コマンド
    
43.     OWN_COMMAND = /([S])[ ]*:[ ]*(\d+)/i
    
44.   end
    
45. end
    
46. 
    
47. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
    
48. 
    
49. #==============================================================================
    
50. # □ KGC::Commands
    
51. #==============================================================================
    
52. 
    
53. module KGC
    
54. module Commands
    
55.   module_function
    
56.   #--------------------------------------------------------------------------
    
57.   # ○ アクターコマンドの変更
    
58.   #     actor_id : アクター ID
    
59.   #     commands : コマンドの配列 (省略時: nil)
    
60.   #--------------------------------------------------------------------------
    
61.   def set_actor_command(actor_id, commands = nil)
    
62.     $game_actors[actor_id].actor_commands = commands
    
63.   end
    
64.   #--------------------------------------------------------------------------
    
65.   # ○ アクターの固有コマンドの登録
    
66.   #     actor_id : アクター ID
    
67.   #     commands : コマンドの配列
    
68.   #--------------------------------------------------------------------------
    
69.   def set_own_command(actor_id, commands)
    
70.     actor = $game_actors[actor_id]
    
71.     actor.clear_own_command            # コマンドをクリア
    
72.     commands.each_with_index { |c, i|  # コマンドを登録
    
73.       actor.set_own_command(i, c)
    
74.     }
    
75.   end
    
76.   #--------------------------------------------------------------------------
    
77.   # ○ アクターの固有コマンドの追加登録
    
78.   #     actor_id : アクター ID
    
79.   #     commands : コマンドの配列
    
80.   #--------------------------------------------------------------------------
    
81.   def add_own_command(actor_id, commands)
    
82.     actor = $game_actors[actor_id]
    
83.     commands.each { |c|                # コマンドを追加登録
    
84.       actor.set_own_command(actor.own_commands.size + 1, c)
    
85.     }
    
86.   end
    
87.   #--------------------------------------------------------------------------
    
88.   # ○ アクターの固有コマンドの削除
    
89.   #     actor_id : アクター ID
    
90.   #     commands : コマンドの配列
    
91.   #--------------------------------------------------------------------------
    
92.   def remove_own_command(actor_id, commands)
    
93.     actor = $game_actors[actor_id]
    
94.     commands.each { |c|                # コマンドを削除
    
95.       actor.remove_own_command(c)
    
96.     }
    
97.   end
    
98.   #--------------------------------------------------------------------------
    
99.   # ○ アクターの固有コマンドのクリア
    
100.   #     actor_id : アクター ID
     
101.   #--------------------------------------------------------------------------
     
102.   def clear_own_command(actor_id)
     
103.     $game_actors[actor_id].clear_own_command
     
104.   end
     
105. end
     
106. end
     
107. 
     
108. class Game_Interpreter
     
109.   include KGC::Commands
     
110. end
     
111. 
     
112. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
113. 
     
114. #==============================================================================
     
115. # ■ Game_Actor
     
116. #==============================================================================
     
117. 
     
118. class Game_Actor < Game_Battler
     
119.   #--------------------------------------------------------------------------
     
120.   # ● 公開インスタンス変数
     
121.   #--------------------------------------------------------------------------
     
122.   attr_writer   :actor_commands           # アクターコマンド
     
123.   attr_writer   :own_commands             # 固有コマンド
     
124.   #--------------------------------------------------------------------------
     
125.   # ● セットアップ
     
126.   #     actor_id : アクター ID
     
127.   #--------------------------------------------------------------------------
     
128.   alias setup_KGC_SeparationCommand setup
     
129.   def setup(actor_id)
     
130.     setup_KGC_SeparationCommand(actor_id)
     
131. 
     
132.     @actor_commands = nil
     
133.     @own_commands = nil
     
134.   end
     
135.   #--------------------------------------------------------------------------
     
136.   # ○ アクターコマンド取得
     
137.   #--------------------------------------------------------------------------
     
138.   def actor_commands
     
139.     if @actor_commands.is_a?(Array)
     
140.       return @actor_commands
     
141.     elsif KGC::SeparationCommand::ACTOR_COMMANDS[actor.id] != nil
     
142.       return KGC::SeparationCommand::ACTOR_COMMANDS[actor.id]
     
143.     else
     
144.       return KGC::SeparationCommand::DEFAULT_COMMANDS
     
145.     end
     
146.   end
     
147.   #--------------------------------------------------------------------------
     
148.   # ○ 固有コマンド取得
     
149.   #--------------------------------------------------------------------------
     
150.   def own_commands
     
151.     clear_own_command if @own_commands == nil
     
152.     result = []
     
153.     @own_commands.each { |c|
     
154.       command = Game_OwnCommand.new(c)
     
155.       result << command if command.valid?  # 有効なコマンドのみ追加
     
156.     }
     
157.     return result
     
158.   end
     
159.   #--------------------------------------------------------------------------
     
160.   # ○ 固有コマンド登録
     
161.   #     index   : 登録場所
     
162.   #     command : スキル ID or コマンド文字列
     
163.   #--------------------------------------------------------------------------
     
164.   def set_own_command(index, command)
     
165.     clear_own_command if @own_commands == nil
     
166.     @own_commands[index] = command
     
167.   end
     
168.   #--------------------------------------------------------------------------
     
169.   # ○ 固有コマンド削除
     
170.   #     command : スキル ID or コマンド文字列
     
171.   #--------------------------------------------------------------------------
     
172.   def remove_own_command(command)
     
173.     clear_own_command if @own_commands == nil
     
174.     @own_commands.delete(command)
     
175.   end
     
176.   #--------------------------------------------------------------------------
     
177.   # ○ 固有コマンドをクリア
     
178.   #--------------------------------------------------------------------------
     
179.   def clear_own_command
     
180.     @own_commands = []
     
181.   end
     
182.   #--------------------------------------------------------------------------
     
183.   # ● スキルの使用可能判定
     
184.   #     skill : スキル
     
185.   #--------------------------------------------------------------------------
     
186.   def skill_can_use?(skill)
     
187.     return super
     
188.   end
     
189. end
     
190. 
     
191. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
192. 
     
193. #==============================================================================
     
194. # □ Game_OwnCommand
     
195. #------------------------------------------------------------------------------
     
196. #   個別戦闘コマンドの情報を格納するクラスです。
     
197. #==============================================================================
     
198. 
     
199. class Game_OwnCommand
     
200.   #--------------------------------------------------------------------------
     
201.   # ○ 定数
     
202.   #--------------------------------------------------------------------------
     
203.   KIND_NONE  = -1  # 無効
     
204.   KIND_SKILL = 0   # スキル
     
205.   #--------------------------------------------------------------------------
     
206.   # ○ 公開インスタンス変数
     
207.   #--------------------------------------------------------------------------
     
208.   attr_accessor :kind                     # コマンドの種類 (/[S]/)
     
209.   attr_accessor :skill_id                 # スキル ID
     
210.   #--------------------------------------------------------------------------
     
211.   # ○ オブジェクト初期化
     
212.   #     command : スキル ID or コマンド文字列
     
213.   #--------------------------------------------------------------------------
     
214.   def initialize(command)
     
215.     @kind = KIND_SKILL
     
216.     @skill_id = 0
     
217.     setup(command)
     
218.   end
     
219.   #--------------------------------------------------------------------------
     
220.   # ○ セットアップ
     
221.   #     command : スキル ID or コマンド文字列
     
222.   #--------------------------------------------------------------------------
     
223.   def setup(command)
     
224.     if command.is_a?(Integer)       # スキル ID
     
225.       @kind = KIND_SKILL
     
226.       @skill_id = command
     
227.     elsif command.is_a?(String) &&  # 文字列
     
228.         command =~ KGC::SeparationCommand::Regexp::OWN_COMMAND
     
229.       case $1.upcase
     
230.       when "S"  # スキル
     
231.         @kind = KIND_SKILL
     
232.         @skill_id = $2.to_i
     
233.       end
     
234.     else                            # 無効
     
235.       @kind = KIND_NONE
     
236.     end
     
237.   end
     
238.   #--------------------------------------------------------------------------
     
239.   # ○ 有効判定
     
240.   #--------------------------------------------------------------------------
     
241.   def valid?
     
242.     return @kind != KIND_NONE
     
243.   end
     
244.   #--------------------------------------------------------------------------
     
245.   # ○ スキル取得
     
246.   #--------------------------------------------------------------------------
     
247.   def skill
     
248.     return nil if @kind != KIND_SKILL
     
249.     return $data_skills[@skill_id]
     
250.   end
     
251. end
     
252. 
     
253. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
254. 
     
255. #==============================================================================
     
256. # ■ Window_ActorCommand
     
257. #==============================================================================
     
258. 
     
259. class Window_ActorCommand < Window_Command
     
260.   #--------------------------------------------------------------------------
     
261.   # ● セットアップ
     
262.   #     actor : アクター
     
263.   #--------------------------------------------------------------------------
     
264.   def setup(actor)
     
265.     create_commands(actor)
     
266.     create_contents
     
267.     refresh
     
268.     apply_command_enabled(actor)
     
269.     self.index = 0
     
270.     setup_name_window(actor) if $imported["ActiveCountBattle"]
     
271.   end
     
272.   #--------------------------------------------------------------------------
     
273.   # ○ コマンドを作成
     
274.   #     actor : アクター
     
275.   #--------------------------------------------------------------------------
     
276.   def create_commands(actor)
     
277.     @command_index = {}
     
278.     @command_enabled = {}
     
279.     @commands = []
     
280. 
     
281.     actor.actor_commands.each { |c|
     
282.       case c
     
283.       when 0  # 攻撃
     
284.         @command_index[:attack] = @commands.size
     
285.         @command_enabled[:attack] = true
     
286.         @commands << Vocab.attack
     
287.       when 1  # スキル
     
288.         @command_index[:skill] = @commands.size
     
289.         @command_enabled[:skill] = true
     
290.         vocab = Vocab.skill
     
291.         if actor.class.skill_name_valid        # スキルのコマンド名が有効？
     
292.           vocab = actor.class.skill_name       # コマンド名を置き換える
     
293.         end
     
294.         @commands << vocab
     
295.       when 2  # 防御
     
296.         @command_index[:guard] = @commands.size
     
297.         @command_enabled[:guard] = true
     
298.         @commands << Vocab.guard
     
299.       when 3  # アイテム
     
300.         @command_index[:item] = @commands.size
     
301.         @command_enabled[:item] = true
     
302.         @commands << Vocab.item
     
303.       when 4  # 固有コマンド
     
304.         @command_index[:own_start] = @commands.size
     
305.         cmd = create_own_commands(actor)
     
306.         unless cmd.empty?
     
307.           @commands += cmd
     
308.           @command_index[:own_end] = @commands.size - 1
     
309.         end
     
310.       end
     
311.     }
     
312.     @item_max = @commands.size
     
313.   end
     
314.   #--------------------------------------------------------------------------
     
315.   # ○ 固有コマンドを作成
     
316.   #     actor : アクター
     
317.   #--------------------------------------------------------------------------
     
318.   def create_own_commands(actor)
     
319.     result = []
     
320.     actor.own_commands.each { |c|
     
321.       next unless c.is_a?(Game_OwnCommand)  # 固有コマンド以外は無視
     
322.       case c.kind
     
323.       when Game_OwnCommand::KIND_SKILL  # スキル
     
324.         skill = c.skill
     
325.         @command_index[skill] = @command_index[:own_start] + result.size
     
326.         @command_enabled[skill] = actor.skill_can_use?(skill)
     
327.         result << skill.name
     
328.       end
     
329.     }
     
330. 
     
331.     return result
     
332.   end
     
333.   #--------------------------------------------------------------------------
     
334.   # ○ コマンドの有効状態を適用
     
335.   #     actor : アクター
     
336.   #--------------------------------------------------------------------------
     
337.   def apply_command_enabled(actor)
     
338.     @command_index.each { |k, v|
     
339.       next if k == :own_start || k == :own_end
     
340.       # 無効状態のコマンドを描画
     
341.       draw_item(v, @command_enabled[k]) unless @command_enabled[k]
     
342.     }
     
343.   end
     
344.   #--------------------------------------------------------------------------
     
345.   # ○ 「攻撃」のインデックス
     
346.   #--------------------------------------------------------------------------
     
347.   def attack_index
     
348.     return @command_index[:attack]
     
349.   end
     
350.   #--------------------------------------------------------------------------
     
351.   # ○ 「スキル」のインデックス
     
352.   #--------------------------------------------------------------------------
     
353.   def skill_index
     
354.     return @command_index[:skill]
     
355.   end
     
356.   #--------------------------------------------------------------------------
     
357.   # ○ 「防御」のインデックス
     
358.   #--------------------------------------------------------------------------
     
359.   def guard_index
     
360.     return @command_index[:guard]
     
361.   end
     
362.   #--------------------------------------------------------------------------
     
363.   # ○ 「アイテム」のインデックス
     
364.   #--------------------------------------------------------------------------
     
365.   def item_index
     
366.     return @command_index[:item]
     
367.   end
     
368.   #--------------------------------------------------------------------------
     
369.   # ○ 「固有コマンド」の開始インデックス
     
370.   #--------------------------------------------------------------------------
     
371.   def own_start_index
     
372.     return @command_index[:own_start]
     
373.   end
     
374.   #--------------------------------------------------------------------------
     
375.   # ○ 「固有コマンド」のインデックス範囲
     
376.   #--------------------------------------------------------------------------
     
377.   def own_index_range
     
378.     if @command_index[:own_end] == nil
     
379.       return nil
     
380.     else
     
381.       return @command_index[:own_start]..@command_index[:own_end]
     
382.     end
     
383.   end
     
384. end
     
385. 
     
386. #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
     
387. 
     
388. #==============================================================================
     
389. # ■ Scene_Battle
     
390. #==============================================================================
     
391. 
     
392. class Scene_Battle
     
393.   #--------------------------------------------------------------------------
     
394.   # ● アクターコマンド選択の更新
     
395.   #--------------------------------------------------------------------------
     
396.   def update_actor_command_selection
     
397.     if Input.trigger?(Input::B)
     
398.       Sound.play_cancel
     
399.       prior_actor
     
400.     elsif Input.trigger?(Input::C)
     
401.       index = @actor_command_window.index
     
402.       case index
     
403.       when @actor_command_window.attack_index     # 攻撃
     
404.         Sound.play_decision
     
405.         @active_battler.action.set_attack
     
406.         start_target_enemy_selection
     
407.       when @actor_command_window.skill_index      # スキル
     
408.         Sound.play_decision
     
409.         start_skill_selection
     
410.       when @actor_command_window.guard_index      # 防御
     
411.         Sound.play_decision
     
412.         @active_battler.action.set_guard
     
413.         next_actor
     
414.       when @actor_command_window.item_index       # アイテム
     
415.         Sound.play_decision
     
416.         start_item_selection
     
417.       when @actor_command_window.own_index_range  # 固有コマンド
     
418.         own_index = index - @actor_command_window.own_start_index
     
419.         process_own_command(own_index)
     
420.       end
     
421.     end
     
422.   end
     
423.   #--------------------------------------------------------------------------
     
424.   # ○ 固有コマンド処理
     
425.   #     index : コマンド index
     
426.   #--------------------------------------------------------------------------
     
427.   def process_own_command(index)
     
428.     command = @active_battler.own_commands[index]
     
429.     if command == nil
     
430.       Sound.play_buzzer
     
431.       return
     
432.     end
     
433. 
     
434.     # コマンドの種類に応じた処理
     
435.     case command.kind
     
436.     when Game_OwnCommand::KIND_SKILL  # スキル
     
437.       @input_own_command = true
     
438.       # ダミーのウィンドウを作成
     
439.       @help_window = Window_Help.new
     
440.       @help_window.visible = false
     
441.       @skill_window = Window_Skill.new(0, 0, 64, 64, @active_battler)
     
442.       @skill_window.active = false
     
443.       @skill_window.visible = false
     
444.       # スキルを選択したと見なす
     
445.       @skill = command.skill
     
446.       if @active_battler.skill_can_use?(@skill)
     
447.         Sound.play_decision
     
448.         determine_skill
     
449.       else
     
450.         Sound.play_buzzer
     
451.       end
     
452.       # ダミーのウィンドウを破棄
     
453.       @help_window.dispose  if @help_window != nil
     
454.       @skill_window.dispose if @skill_window != nil
     
455.       @help_window = nil
     
456.       @skill_window = nil
     
457.     else                              # 不明なコマンド
     
458.       Sound.play_buzzer
     
459.     end
     
460.     @input_own_command = false
     
461.   end
     
462.   #--------------------------------------------------------------------------
     
463.   # ● 対象敵キャラ選択の終了
     
464.   #--------------------------------------------------------------------------
     
465.   alias end_target_enemy_selection_KGC_SeparationCommand end_target_enemy_selection
     
466.   def end_target_enemy_selection
     
467.     end_target_enemy_selection_KGC_SeparationCommand
     
468. 
     
469.     case @actor_command_window.index
     
470.     when @actor_command_window.attack_index,     # 攻撃または
     
471.           @actor_command_window.own_index_range  # 固有コマンドの場合
     
472.       @actor_command_window.active = true         # アクターコマンドに戻る
     
473.     else
     
474.       @actor_command_window.active = false
     
475.     end
     
476.   end
     
477.   #--------------------------------------------------------------------------
     
478.   # ● 対象アクター選択の終了
     
479.   #--------------------------------------------------------------------------
     
480.   alias end_target_actor_selection_KGC_SeparationCommand end_target_actor_selection
     
481.   def end_target_actor_selection
     
482.     end_target_actor_selection_KGC_SeparationCommand
     
483. 
     
484.     case @actor_command_window.index
     
485.     when @actor_command_window.own_index_range  # 固有コマンドの場合
     
486.       @actor_command_window.active = true        # アクターコマンドに戻る
     
487.     else
     
488.       @actor_command_window.active = false
     
489.     end
     
490.   end
     
491. end
     
492. 
     

复制代码