关于这个ATB脚本报错

jiazaixime

1. #==============================================================================
   
2. # ** Victor Engine - Active Time Battle
   
3. #------------------------------------------------------------------------------
   
4. # Author : Victor Sant
   
5. #
   
6. # Version History:
   
7. #  v 1.00 - 2012.12.16 > First release
   
8. #  v 1.01 - 2012.12.24 > Fixed issue with changing party during battle
   
9. #                      > Fixed ATB value during Surprise and Pre Emptive
   
10. #                      > Fixed Command Window position to not cover the ATB
    
11. #                      > Fixed issue with freezes after events
    
12. #                      > Fixed issue with state timings
    
13. #                      > Fixed issue with cast time at battle start
    
14. #                      > Fixed issue with escape at battle start
    
15. #                      > Added notetags <timed trigger: x> <cast protection: x>
    
16. #                        and <delay protection>
    
17. #                      > Fixed issue with command window not closing when
    
18. #                        the actor is becomes unable to select action
    
19. #  v 1.02 - 2012.12.30 > Compatibility with Leap Attack
    
20. #                      > Fixed issue with Guard command and ATB Reverse
    
21. #  v 1.03 - 2013.01.07 > Fixed issue with selection when all enemies are dead
    
22. #  v 1.04 - 2013.01.24 > Fixed issue with skill, item and target windows not
    
23. #                        closing when the actor is becomes unable to act
    
24. #  v 1.05 - 2013.02.13 > Added notetag <atb speed: x%>
    
25. #                      > Added setup for play a SE when the ATB is full
    
26. #------------------------------------------------------------------------------
    
27. #  This scripts changes the turn management of battles. The default turn based
    
28. # system is replaced by an active time system, where the order of actions
    
29. # are decided by individual time bars
    
30. #------------------------------------------------------------------------------
    
31. # Compatibility
    
32. #   Requires the script 'Victor Engine - Basic Module' v 1.32 or higher
    
33. #   If used with 'Victor Engine - Animated Battle' place this bellow it.
    
34. #   If used with 'Victor Engine - Skip Battle Log' place this bellow it.
    
35. #
    
36. # * Overwrite methods
    
37. #   class << BattleManager
    
38. #     def next_command
    
39. #     def prior_command
    
40. #     def turn_start
    
41. #     def turn_end
    
42. #     def make_action_orders
    
43. #
    
44. #   class Game_Enemy < Game_Battler
    
45. #     def conditions_met_turns?(param1, param2)
    
46. #
    
47. #   class Window_BattleStatus < Window_Selectable
    
48. #     def window_width
    
49. #     def draw_basic_area(rect, actor)
    
50. #     def draw_gauge_area_with_tp(rect, actor)
    
51. #     def draw_gauge_area_without_tp(rect, actor)
    
52. #     def update
    
53. #
    
54. # * Alias methods
    
55. #   class << BattleManager
    
56. #     def init_members
    
57. #     def battle_start
    
58. #     def process_escape
    
59. #
    
60. #   class Game_System
    
61. #     def initialize
    
62. #
    
63. #   class Game_Action
    
64. #     def prepare
    
65. #
    
66. #   class Game_BattlerBase
    
67. #     def inputable?
    
68. #
    
69. #   class Game_Battler < Game_BattlerBase
    
70. #     def item_user_effect(user, item)
    
71. #
    
72. #   class Game_Enemy < Game_Battler
    
73. #     def initialize(index, enemy_id)
    
74. #
    
75. #   class Spriteset_Battle
    
76. #     def update_actors
    
77. #
    
78. #   class Window_BattleLog < Window_Selectable
    
79. #     def last_text
    
80. #
    
81. #   class Window_ActorCommand < Window_Command
    
82. #     def make_command_list
    
83. #
    
84. #------------------------------------------------------------------------------
    
85. # Instructions:
    
86. #  To instal the script, open you script editor and paste this script on
    
87. #  a new section bellow the Materials section. This script must also
    
88. #  be bellow the script 'Victor Engine - Basic'
    
89. #
    
90. #------------------------------------------------------------------------------
    
91. # Actors, Classes, Enemies, Weapons, Armors, States, Skills and Items note tags:
    
92. #   Tags to be used on Actors, Classes, Enemies, Weapons, Armors, States,
    
93. #   Skills and Items note boxes.
    
94. #
    
95. #  <cast cancel: x%>
    
96. #   Actions will have a chance of canceling spell casting of the targets.
    
97. #     x : success rate
    
98. #
    
99. #  <atb delay: x%, y%>
    
100. #   Actions will have a chance of delaying the ATB of the targets.
     
101. #     x : success rate
     
102. #     y : delay rate
     
103. #
     
104. #------------------------------------------------------------------------------
     
105. # Actors, Classes, Enemies, Weapons, Armors and States note tags:
     
106. #   Tags to be used on Actors, Classes, Enemies, Weapons, Armors and States
     
107. #   note boxes.
     
108. #
     
109. #  <cast protection: x%>
     
110. #   Reduce the success rate of a cast cancel action.
     
111. #     x : reduction
     
112. #
     
113. #  <delay protection: x%>
     
114. #   Reduce the success rate of a atb delay action.
     
115. #     x : reduction
     
116. #
     
117. #  <atb speed: x%>
     
118. #   Changes the rate of a atb fill speed. if the value is higher then 100%
     
119. #   the bar fills faster, if it's lower than 100% the bar fills slower.
     
120. #     x : speed rate
     
121. #
     
122. #------------------------------------------------------------------------------
     
123. # Skills note tags:
     
124. #   Tags to be used on Skills note boxes.
     
125. #
     
126. #  <cast time: x>
     
127. #  <cast time: x, y>
     
128. #   Actions with this will have a cast time before executing, you can add
     
129. #   opitionally wich stat will be used to define the speed.
     
130. #     x : cast speed (100 = default speed)
     
131. #     y : stat (any valid battler stat)
     
132. #
     
133. #  <atb cost: x%>
     
134. #   Changes the total ATB spent after executing an action. By default all
     
135. #   actions cost 100% of the ATB. Can't be lower than 1%
     
136. #     x : ATB cost rate
     
137. #
     
138. #------------------------------------------------------------------------------
     
139. # States note tags:
     
140. #   Tags to be used on States note boxes.
     
141. #
     
142. #  <timed trigger: x>
     
143. #   There is two options for state auto-removal on the database: Action End
     
144. #   and Turn End. This tag creates a third option, to make the state end
     
145. #   and trigger after a set time.
     
146. #     x : time for the trigger.
     
147. #
     
148. #------------------------------------------------------------------------------
     
149. # Additional instructions:
     
150. #
     
151. #  The <cast cancel: x%> and <atb delay: x%, y%> will have effect only on
     
152. #  physical actions when added to any object beside Skills and Items.
     
153. #
     
154. #  The <cast protection: x%> and <delay protection: x%> are multiplied by
     
155. #  the cast cancel/atb delay rate. So if an action have 30% cast cancel, and
     
156. #  the target have 50% cast protection, the cast cancel will be reduced to 15%
     
157. #  Multiple cast cancel effects are added separately. So an action with 40%
     
158. #  cast cancel and a target with 50%, 50% and 30% cast protection from different
     
159. #  sourcers (let's say 3 different equips) will have the chance reduced to 7%
     
160. #  (40 - 50% = 20%, 20% - 50% = 10%, 10% - 30% = 7%)
     
161. #
     
162. #  The <atb speed: x%> can be used to change the rate of a battler ATB speed
     
163. #  without the need of changing the AGI of the battler. Can be used to create
     
164. #  effect such as "Haste" and "Slow".
     
165. #
     
166. #  You can use script calls to change the wait mode and the atb speed
     
167. #  $game_system.wait_mode = X
     
168. #     :full_wait : time stop to select commands and actions
     
169. #     :semi_wait : time stop to select actions
     
170. #     :active    : time don't stop
     
171. #
     
172. #  $game_system.atb_speed = X
     
173. #    1.0 = default speed
     
174. #
     
175. #==============================================================================
     
176. 
     
177. #==============================================================================
     
178. # ** Victor Engine
     
179. #------------------------------------------------------------------------------
     
180. #   Setting module for the Victor Engine
     
181. #==============================================================================
     
182. 
     
183. module Victor_Engine
     
184.   #--------------------------------------------------------------------------
     
185.   # * Wait mode
     
186.   #   :full_wait : time stop to select commands and actions
     
187.   #   :semi_wait : time stop to select actions
     
188.   #   :active    : time don't stop
     
189.   #--------------------------------------------------------------------------
     
190.   VE_ATB_WAIT_MODE = :full_wait
     
191.   #--------------------------------------------------------------------------
     
192.   # * Action wait
     
193.   #   if true, time will stop while executing actions
     
194.   #--------------------------------------------------------------------------
     
195.   VE_ATB_WAIT_ACTION = true
     
196.   #--------------------------------------------------------------------------
     
197.   # * Reverse ATB
     
198.   #   This setting revert how the ATB works, instead waiting the bar to fill
     
199.   #   up to select actions, you first select the action, the the bar start
     
200.   #   to fill and the action is executed once it's full.
     
201.   #--------------------------------------------------------------------------
     
202.   VE_ATB_REVERSE = false
     
203.   #--------------------------------------------------------------------------
     
204.   # * Move status window
     
205.   #   Setup this true to move the status window when the actor command
     
206.   #   window or part command window shows up. If false, both windows will
     
207.   #   be displayed above the status window.
     
208.   #--------------------------------------------------------------------------
     
209.   VE_MOVE_STATUS_WINDOW = true
     
210.   #--------------------------------------------------------------------------
     
211.   # * ATB Full Sound
     
212.   #   Play a sound when the actor command window open. Leave nil for no sound
     
213.   #   RPG::SE.new(filename, volume, pitch)
     
214.   #--------------------------------------------------------------------------
     
215.   VE_ATB_SOUND = RPG::SE.new("Decision2", 100, 100)
     
216.   #--------------------------------------------------------------------------
     
217.   # * Escape type
     
218.   #   :party   : open party menu by pressing the cancel key
     
219.   #   :command : add the "Escape" option to actors command list
     
220.   #   :key     : press the set keys for a while to escape
     
221.   #--------------------------------------------------------------------------
     
222.   VE_ATB_ESCAPE_TYPE = :command
     
223.   #--------------------------------------------------------------------------
     
224.   # * Setup the key that must be pressed for escaping
     
225.   #    :A >> keyboard Shift  :B >> keyboard X      :C >> keyboard Z
     
226.   #    :X >> keyboard A      :Y >> keyboard S      :Z >> keyboard D
     
227.   #    :L >> keyboard Q      :R >> keyboard W
     
228.   #   adding more than one key makes need to press all of them at same time
     
229.   #--------------------------------------------------------------------------
     
230.   VE_ATB_ESCAPE_KEYS = [:R, :L]
     
231.   #--------------------------------------------------------------------------
     
232.   # * Escape time
     
233.   #  Average escape time in frames to escape if VE_ATB_ESCAPE_TYPE = :key
     
234.   #  This value vary based on the battlers stats and the ATB speed
     
235.   #--------------------------------------------------------------------------
     
236.   VE_ATB_ESCAPE_TIME = 200
     
237.   #--------------------------------------------------------------------------
     
238.   # * Escape text
     
239.   #   Display escape text when trying to escape if VE_ATB_ESCAPE_TYPE = :key
     
240.   #--------------------------------------------------------------------------
     
241.   VE_ATB_ESCAPE_TEXT = true
     
242.   #--------------------------------------------------------------------------
     
243.   # * Turn count control
     
244.   #  This is used to control how the turn count will increase, the turn count
     
245.   #  control the battle event conditions
     
246.   #   :time     : control by time (in frames)
     
247.   #   :battlers : control by the number of alive battlers
     
248.   #   :actions  : control by the number of actions executed
     
249.   #--------------------------------------------------------------------------
     
250.   VE_ATB_TURN_COUNT = :time
     
251.   #--------------------------------------------------------------------------
     
252.   # * Time count
     
253.   #   Valid only if VE_ATB_TURN_COUNT = :time, setup the number of frames
     
254.   #   needed to increase the turn count. Is influenced by the ATB speed
     
255.   #--------------------------------------------------------------------------
     
256.   VE_ATB_TIME_COUNT = 200
     
257.   #--------------------------------------------------------------------------
     
258.   # * Action count
     
259.   #   Valid only if VE_ATB_TURN_COUNT = :actions, setup the number of actions
     
260.   #   needed to increase the turn count
     
261.   #--------------------------------------------------------------------------
     
262.   VE_ATB_ACTION_COUNT = 10
     
263.   #--------------------------------------------------------------------------
     
264.   # * ATB speed
     
265.   #   Multiplier that controls the speed of the ATB bars
     
266.   #--------------------------------------------------------------------------
     
267.   VE_ATB_SPEED = 1.0
     
268.   #--------------------------------------------------------------------------
     
269.   # * Speed modifier
     
270.   #   Value used to control the influence of the stats on the ATB speed
     
271.   #   Higher values reduce the influence of the stats on the speed.
     
272.   #--------------------------------------------------------------------------
     
273.   VE_speed_modifier = 50
     
274.   #--------------------------------------------------------------------------
     
275.   # * Start rate
     
276.   #   Initial ATB value on battle start, a random value between 0 and X%
     
277.   #--------------------------------------------------------------------------
     
278.   VE_ATB_START_RATE = 10
     
279.   #--------------------------------------------------------------------------
     
280.   # * Reverse ATB Guard Time
     
281.   #   With VE_ATB_REVERSE = true the guard time is set by this value, not
     
282.   #   by the value set on the database
     
283.   #--------------------------------------------------------------------------
     
284.   VE_ATB_REVERSE_GUARD_TIME = 150
     
285.   #--------------------------------------------------------------------------
     
286.   # * Default magic cast
     
287.   #   Setup a default cast speed for all magic skills.
     
288.   #   Leave nil for no cast time.
     
289.   #     100 = default speed (same as the default wait time for actions)
     
290.   #--------------------------------------------------------------------------
     
291.   VE_ATB_DEFAULT_CAST = nil
     
292.   #--------------------------------------------------------------------------
     
293.   # * Damage wait
     
294.   #   Stop battler wait time during hurt animation. Available only for
     
295.   #   Animated Battle
     
296.   #--------------------------------------------------------------------------
     
297.   VE_ATB_DAMAGE_WAIT = true
     
298.   #--------------------------------------------------------------------------
     
299.   # * Escaping animation
     
300.   #   Add a steping animation while holding the escape key. Available only for
     
301.   #   Animated Battle and if VE_ATB_ESCAPE_TYPE = :key
     
302.   #--------------------------------------------------------------------------
     
303.   VE_ATB_ESCAPING_ANIM = true
     
304.   #--------------------------------------------------------------------------
     
305.   # * Regenerarion Trigger
     
306.   #  All regen effects triggers at same time no matter of the source, here
     
307.   #  you can set when the regen trigger
     
308.   #    :turn   : at the turn end
     
309.   #    :action : at the action end
     
310.   #    :timing : at fixed intervals
     
311.   #   It's highly recomended to setup all regen and poison states with the
     
312.   #   same auto-removal condition to ensure the duration match the trigger
     
313.   #--------------------------------------------------------------------------
     
314.   VE_ATB_REGEN_TRIGGER = :action
     
315.   #--------------------------------------------------------------------------
     
316.   # * Regenerarion Timing
     
317.   #  Time for regen effects to apply if VE_ATB_REGEN_TRIGGER = :timing
     
318.   #  Is influenced by the ATB speed
     
319.   #--------------------------------------------------------------------------
     
320.   VE_ATB_REGEN_TIMING = 300
     
321.   #--------------------------------------------------------------------------
     
322.   # * required
     
323.   #   This method checks for the existance of the basic module and other
     
324.   #   VE scripts required for this script to work, don't edit this
     
325.   #--------------------------------------------------------------------------
     
326.   def required(name, req, version, type = nil)
     
327.     if !$imported[:ve_basic_module]
     
328.       msg = "The script '%s' requires the script\n"
     
329.       msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
     
330.       msg += "Go to [url]http://victorscripts.wordpress.com/[/url] to download this script."
     
331.       msgbox(sprintf(msg, self.script_name(name), version))
     
332.       exit
     
333.     else
     
334.       self.required_script(name, req, version, type)
     
335.     end
     
336.   end
     
337.   #--------------------------------------------------------------------------
     
338.   # * script_name
     
339.   #   Get the script name base on the imported value
     
340.   #--------------------------------------------------------------------------
     
341.   def script_name(name, ext = "VE")
     
342.     name = name.to_s.gsub("_", " ").upcase.split
     
343.     name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
     
344.     name.join(" ")
     
345.   end
     
346. end
     
347. 
     
348. $imported ||= {}
     
349. $imported[:ve_active_time_battle] = 1.05
     
350. Victor_Engine.required(:ve_active_time_battle, :ve_basic_module, 1.32, :above)
     
351. Victor_Engine.required(:ve_active_time_battle, :ve_state_auto_apply, 1.00, :bellow)
     
352. Victor_Engine.required(:ve_active_time_battle, :ve_damage_pop, 1.00, :bellow)
     
353. Victor_Engine.required(:ve_active_time_battle, :ve_leap_attack, 1.00, :bellow)
     
354. Victor_Engine.required(:ve_active_time_battle, :ve_cooperation_skill, 1.00, :bellow)
     
355. 
     
356. #==============================================================================
     
357. # ** Vocab
     
358. #------------------------------------------------------------------------------
     
359. #  This module defines terms and messages. It defines some data as constant
     
360. # variables. Terms in the database are obtained from $data_system.
     
361. #==============================================================================
     
362. 
     
363. module Vocab
     
364. 
     
365.   # ATB stat name show above atb bar
     
366.   VE_ATB_Name = "ATB"
     
367. 
     
368.   # Message displayed when trying to escape using VE_ATB_ESCAPE_TYPE = :key
     
369.   VE_Escaping = "逃跑..."
     
370. 
     
371.   # Message displayed when can't escape using VE_ATB_ESCAPE_TYPE = :key
     
372.   VE_CantEscape = "逃跑失败!"
     
373. 
     
374. end
     
375. 
     
376. #==============================================================================
     
377. # ** class RPG::BaseItem
     
378. #------------------------------------------------------------------------------
     
379. #  Superclass of actor, class, skill, item, weapon, armor, enemy, and state.
     
380. #==============================================================================
     
381. 
     
382. class RPG::BaseItem
     
383.   #--------------------------------------------------------------------------
     
384.   # * New method: atb_speed
     
385.   #--------------------------------------------------------------------------
     
386.   def atb_speed
     
387.     return @atb_speed if @atb_speed
     
388.     @atb_speed = note =~ /<ATB SPEED: *(\d+)%?>/i ? [$1.to_f, 1].max / 100 : 1
     
389.     @atb_speed
     
390.   end
     
391. end
     
392. 
     
393. #==============================================================================
     
394. # ** RPG::UsableItem
     
395. #------------------------------------------------------------------------------
     
396. #  This is the superclass for skills and items.
     
397. #==============================================================================
     
398. 
     
399. class RPG::UsableItem < RPG::BaseItem
     
400.   #--------------------------------------------------------------------------
     
401.   # * New method: castable?
     
402.   #--------------------------------------------------------------------------
     
403.   def castable?
     
404.     (cast_speed && not_cooperation?) ? true : false
     
405.   end
     
406.   #--------------------------------------------------------------------------
     
407.   # * New method: not_cooperation?
     
408.   #--------------------------------------------------------------------------
     
409.   def not_cooperation?
     
410.     !$imported[:ve_cooperation_skill] || !cooperation?
     
411.   end
     
412.   #--------------------------------------------------------------------------
     
413.   # * New method: cast_speed
     
414.   #--------------------------------------------------------------------------
     
415.   def cast_speed
     
416.     regexp = /<CAST TIME: (\d+)(?:, *(\w+))?>/i
     
417.     note   =~ regexp ? {spd: $1.to_i, stat: ($2 ? $2 : "agi")} : default_cast
     
418.   end
     
419.   #--------------------------------------------------------------------------
     
420.   # * New method: default_cast
     
421.   #--------------------------------------------------------------------------
     
422.   def default_cast
     
423.     speed = VE_ATB_DEFAULT_CAST
     
424.     ((magical? && speed) || VE_ATB_REVERSE) ? {spd: speed, stat: "agi"} : nil
     
425.   end
     
426.   #--------------------------------------------------------------------------
     
427.   # * New method: atb_cost
     
428.   #--------------------------------------------------------------------------
     
429.   def atb_cost
     
430.     regexp = /<ATB COST: (\d+)%?>/i
     
431.     note  =~ regexp ? [1.0 - ($1.to_f / 100), 0].max : 0
     
432.   end
     
433.   #--------------------------------------------------------------------------
     
434.   # * New method: cast_cancel
     
435.   #--------------------------------------------------------------------------
     
436.   def cast_cancel
     
437.     regexp = /<CAST CANCEL: (\d+)%?>/i
     
438.     note  =~ regexp ? $1.to_f / 100 : 0
     
439.   end
     
440.   #--------------------------------------------------------------------------
     
441.   # * New method: atb_delay
     
442.   #--------------------------------------------------------------------------
     
443.   def guard_skill?
     
444.     effects.any? {|effect| effect.code == 21 && effect.data_id == 9 }
     
445.   end
     
446.   #--------------------------------------------------------------------------
     
447.   # * New method: atb_delay
     
448.   #--------------------------------------------------------------------------
     
449.   def atb_delay
     
450.     regexp = /<ATB DELAY: (\d+)%?, *([+-]?\d+)%?>/i
     
451.     note   =~ regexp ? {rate: $1.to_f / 100, delay: $2.to_f / 100} :
     
452.                        {rate: 0, delay: 0}
     
453.   end
     
454. end
     
455. 
     
456. #==============================================================================
     
457. # ** RPG::State
     
458. #------------------------------------------------------------------------------
     
459. #  This is the data class for states
     
460. #==============================================================================
     
461. 
     
462. class RPG::State < RPG::BaseItem
     
463.   #--------------------------------------------------------------------------
     
464.   # * Alias method: auto_removal_timing
     
465.   #--------------------------------------------------------------------------
     
466.   alias :auto_removal_timing_ve_active_time_battle :auto_removal_timing
     
467.   def auto_removal_timing
     
468.     timed_trigger ? 3 : auto_removal_timing_ve_active_time_battle
     
469.   end
     
470.   #--------------------------------------------------------------------------
     
471.   # * New method: timed_trigger
     
472.   #--------------------------------------------------------------------------
     
473.   def timed_trigger
     
474.     return @timed_trigger if @timed_trigger
     
475.     return VE_ATB_REVERSE_GUARD_TIME if guard_state?
     
476.     @timed_trigger = note =~ /<TIMED TRIGGER: (\d+)>/i ? $1.to_i : nil
     
477.   end
     
478.   #--------------------------------------------------------------------------
     
479.   # * New method: guard_state?
     
480.   #--------------------------------------------------------------------------
     
481.   def guard_state?
     
482.     features.any? {|ft| ft.code == 62 && ft.data_id == 1 }
     
483.   end
     
484. end
     
485. 
     
486. #==============================================================================
     
487. # ** BattleManager
     
488. #------------------------------------------------------------------------------
     
489. #  This module handles the battle processing
     
490. #==============================================================================
     
491. 
     
492. class << BattleManager
     
493.   #--------------------------------------------------------------------------
     
494.   # * Public Instance Variables
     
495.   #--------------------------------------------------------------------------
     
496.   attr_reader   :input_battlers
     
497.   #--------------------------------------------------------------------------
     
498.   # * Overwrite method: next_command
     
499.   #--------------------------------------------------------------------------
     
500.   def next_command
     
501.     begin
     
502.       return false if !actor || !actor.next_command
     
503.     end until actor.inputable?
     
504.     return true
     
505.   end
     
506.   #--------------------------------------------------------------------------
     
507.   # * Overwrite method: prior_command
     
508.   #--------------------------------------------------------------------------
     
509.   def prior_command
     
510.     begin
     
511.       if !actor || !actor.prior_command
     
512.         old_actor = actor
     
513.         @actor_index -= 1
     
514.         @actor_index %= $game_party.members.size
     
515.         return false if old_actor == actor
     
516.       end
     
517.     end until actor.inputable?
     
518.     return true
     
519.   end
     
520.   #--------------------------------------------------------------------------
     
521.   # * Overwrite method: turn_start
     
522.   #--------------------------------------------------------------------------
     
523.   def turn_start
     
524.     @phase = :turn
     
525.     make_action_orders
     
526.   end
     
527.   #--------------------------------------------------------------------------
     
528.   # * Overwrite method: turn_end
     
529.   #--------------------------------------------------------------------------
     
530.   def turn_end
     
531.     @phase = :turn_end
     
532.     $game_troop.increase_turn
     
533.     @atb_turn_count = 0
     
534.     @abt_turn_speed = setup_atb_turn_speed
     
535.     all_battle_members.each do |battler|
     
536.       battler.on_turn_end
     
537.       next if scene_changing?
     
538.       SceneManager.scene.refresh_status
     
539.       SceneManager.scene.log_window.display_auto_affected_status(battler)
     
540.       SceneManager.scene.log_window.wait_and_clear
     
541.     end
     
542.   end
     
543.   #--------------------------------------------------------------------------
     
544.   # * Overwrite method: make_action_orders
     
545.   #--------------------------------------------------------------------------
     
546.   def make_action_orders
     
547.     @action_battlers += @active_members
     
548.     @active_members.clear
     
549.   end
     
550.   #--------------------------------------------------------------------------
     
551.   # * Alias method: init_members
     
552.   #--------------------------------------------------------------------------
     
553.   alias :init_members_ve_active_time_battle :init_members
     
554.   def init_members
     
555.     init_members_ve_active_time_battle   
     
556.     @abt_turn_speed   = setup_atb_turn_speed
     
557.     @escape_time      = 0
     
558.     @atb_turn_count   = 0
     
559.     @key_escape_count = 0
     
560.     @input_battlers   = []
     
561.     @active_members   = []
     
562.     @action_battlers  = []
     
563.   end
     
564.   #--------------------------------------------------------------------------
     
565.   # * Alias method: battle_start
     
566.   #--------------------------------------------------------------------------
     
567.   alias :battle_start_ve_active_time_battle :battle_start
     
568.   def battle_start
     
569.     battle_start_ve_active_time_battle
     
570.     setup_initial_atb
     
571.     @phase = :turn
     
572.   end
     
573.   #--------------------------------------------------------------------------
     
574.   # * Alias method: process_escape
     
575.   #--------------------------------------------------------------------------
     
576.   alias :process_escape_ve_active_time_battle :process_escape
     
577.   def process_escape
     
578.     @preemptive = true if @escape_success
     
579.     @escape_success = false
     
580.     process_escape_ve_active_time_battle
     
581.   end
     
582.   #--------------------------------------------------------------------------
     
583.   # * New method: update_atb
     
584.   #--------------------------------------------------------------------------
     
585.   def update_atb
     
586.     clear_dead_atb
     
587.     return if scene_changing?
     
588.     return if $game_troop.interpreter.running?
     
589.     return if SceneManager.scene.party_window?
     
590.     return if $imported[:ve_animated_battle] && @escaping
     
591.     update_timing
     
592.     update_turn
     
593.     update_all_atb
     
594.     update_input
     
595.     update_escaping
     
596.   end
     
597.   #--------------------------------------------------------------------------
     
598.   # * New method: setup_initial_atb
     
599.   #--------------------------------------------------------------------------
     
600.   def setup_initial_atb
     
601.     @escape_success = false
     
602.     @key_escaping   = false
     
603.     @escap_pose     = false
     
604.     @party_escaping = false
     
605.     all_battle_members.each {|battler| battler.cast_action = nil }
     
606.     if @preemptive
     
607.       $game_party.members.each {|battler| battler.atb = battler.max_atb }
     
608.       $game_troop.members.each {|battler| battler.atb = 0 }
     
609.     elsif @surprise
     
610.       $game_party.members.each {|battler| battler.atb = 0 }
     
611.       $game_troop.members.each {|battler| battler.atb = battler.max_atb }
     
612.     else
     
613.       all_battle_members.each {|battler| battler.preset_atb }
     
614.     end
     
615.   end
     
616.   #--------------------------------------------------------------------------
     
617.   # * New method: scene_changing?
     
618.   #--------------------------------------------------------------------------
     
619.   def scene_changing?
     
620.     !SceneManager.scene_is?(Scene_Battle)
     
621.   end
     
622.   #--------------------------------------------------------------------------
     
623.   # * New method: update_all_atb
     
624.   #--------------------------------------------------------------------------
     
625.   def update_all_atb
     
626.     return if wating?
     
627.     all_battle_members.each {|member| member.atb_update }
     
628.   end
     
629.   #--------------------------------------------------------------------------
     
630.   # * New method: wating?
     
631.   #--------------------------------------------------------------------------
     
632.   def wating?
     
633.     return true if scene_changing?
     
634.     return true if $game_troop.interpreter.running?
     
635.     return true if SceneManager.scene.full_wait?
     
636.     return true if SceneManager.scene.semi_wait?
     
637.     return true if wait_action?
     
638.     return false
     
639.   end
     
640.   #--------------------------------------------------------------------------
     
641.   # * New method: update_escaping
     
642.   #--------------------------------------------------------------------------
     
643.   def update_escaping
     
644.     open_party_command   if VE_ATB_ESCAPE_TYPE == :party
     
645.     process_party_escape if VE_ATB_ESCAPE_TYPE == :party && party_escape?
     
646.     key_press_escape     if VE_ATB_ESCAPE_TYPE == :key
     
647.     process_escape       if VE_ATB_ESCAPE_TYPE == :key   && key_escape?
     
648.   end
     
649.   #--------------------------------------------------------------------------
     
650.   # * New method: open_party_command
     
651.   #--------------------------------------------------------------------------
     
652.   def open_party_command
     
653.     return if scene_changing?
     
654.     return if SceneManager.scene.windows_active?
     
655.     SceneManager.scene.open_party_command_selection if Input.trigger?(:B)
     
656.   end
     
657.   #--------------------------------------------------------------------------
     
658.   # * New method: party_escape?
     
659.   #--------------------------------------------------------------------------
     
660.   def party_escape?
     
661.     $game_party.alive_members.all? {|actor| actor.atb_full? } &&
     
662.     all_battle_members.all? {|battler| !active_battler?(battler) }
     
663.   end
     
664.   #--------------------------------------------------------------------------
     
665.   # * New method: process_party_escape
     
666.   #--------------------------------------------------------------------------
     
667.   def process_party_escape
     
668.     $game_party.members.each do |battler|
     
669.       battler.atb = 0
     
670.       battler.cast_action = nil
     
671.       battler.clear_actions
     
672.     end
     
673.     @party_escaping = false
     
674.     return if process_escape
     
675.     turn_start
     
676.     SceneManager.scene.battle_start_open_window unless scene_changing?
     
677.   end
     
678.   #--------------------------------------------------------------------------
     
679.   # * New method: key_press_escape
     
680.   #--------------------------------------------------------------------------
     
681.   def key_press_escape
     
682.     @key_escaping = VE_ATB_ESCAPE_KEYS.all? {|key| Input.press?(key)}
     
683.     update_escape_time
     
684.   end
     
685.   #--------------------------------------------------------------------------
     
686.   # * New method: key_escape?
     
687.   #--------------------------------------------------------------------------
     
688.   def key_escape?
     
689.     all_battle_members.all? {|battler| !active?(battler) } && @escape_success
     
690.   end
     
691.   #--------------------------------------------------------------------------
     
692.   # * New method: update_escape_time
     
693.   #--------------------------------------------------------------------------
     
694.   def update_escape_time
     
695.     return if @escape_success
     
696.     escaping? ? increase_escape_time : decrease_escape_time
     
697.   end
     
698.   #--------------------------------------------------------------------------
     
699.   # * New method: increase_escape_time
     
700.   #--------------------------------------------------------------------------
     
701.   def increase_escape_time
     
702.     reset_escape_pose if !reset_escape_pose?
     
703.     @escap_pose = true
     
704.     if BattleManager.can_escape?
     
705.       @escape_time   = [@escape_time + 5 + rand, max_escape_time].min
     
706.       @escape_success = @escape_time == max_escape_time
     
707.     end
     
708.   end
     
709.   #--------------------------------------------------------------------------
     
710.   # * New method: decrease_escape_time
     
711.   #--------------------------------------------------------------------------
     
712.   def decrease_escape_time
     
713.     reset_escape_pose if reset_escape_pose?
     
714.     @escap_pose  = false
     
715.     @escape_time = [@escape_time - 1, 0].max
     
716.   end
     
717.   #--------------------------------------------------------------------------
     
718.   # * New method: reset_escape_pose
     
719.   #--------------------------------------------------------------------------
     
720.   def reset_escape_pose
     
721.     $game_party.alive_members.each {|actor| actor.reset_pose if !actor.active? }
     
722.   end
     
723.   #--------------------------------------------------------------------------
     
724.   # * New method: reset_escape_pose?
     
725.   #--------------------------------------------------------------------------
     
726.   def reset_escape_pose?
     
727.     $imported[:ve_animated_battle] && @escap_pose && VE_ATB_ESCAPING_ANIM
     
728.   end
     
729.   #--------------------------------------------------------------------------
     
730.   # * New method: max_escape_time
     
731.   #--------------------------------------------------------------------------
     
732.   def max_escape_time
     
733.     10.0 * VE_ATB_ESCAPE_TIME * @escape_ratio * $game_system.atb_speed
     
734.   end
     
735.   #--------------------------------------------------------------------------
     
736.   # * New method: wait_action?
     
737.   #--------------------------------------------------------------------------
     
738.   def wait_action?
     
739.     $imported[:ve_animated_battle]  && !scene_changing? &&
     
740.     SceneManager.scene.wait_action? && SceneManager.scene.active?
     
741.   end
     
742.   #--------------------------------------------------------------------------
     
743.   # * New method: update_turn
     
744.   #--------------------------------------------------------------------------
     
745.   def update_turn
     
746.     return if wating?
     
747.     increase_atb_turn_count(:time)
     
748.     SceneManager.scene.turn_ending if @atb_turn_count >= @abt_turn_speed
     
749.   end
     
750.   #--------------------------------------------------------------------------
     
751.   # * New method: update_timing
     
752.   #--------------------------------------------------------------------------
     
753.   def update_timing
     
754.     return if wating?
     
755.     all_battle_members.each {|battler| battler.on_timing }
     
756.   end
     
757.   #--------------------------------------------------------------------------
     
758.   # * New method: update_input
     
759.   #--------------------------------------------------------------------------
     
760.   def update_input
     
761.     all_battle_members.reverse.each do |battler|
     
762.       next if (@party_escaping && battler.actor?) || !battler.ready?
     
763.       @input_battlers.push(battler)
     
764.       battler.on_action_start
     
765.       skill_window.refresh if skill_window.active
     
766.       item_window.refresh  if item_window.active
     
767.     end
     
768.     shift_input unless @input_battlers.empty?
     
769.   end
     
770.   #--------------------------------------------------------------------------
     
771.   # * New method: skill_window
     
772.   #--------------------------------------------------------------------------
     
773.   def skill_window
     
774.     SceneManager.scene.skill_window
     
775.   end
     
776.   #--------------------------------------------------------------------------
     
777.   # * New method: item_window
     
778.   #--------------------------------------------------------------------------
     
779.   def item_window
     
780.     SceneManager.scene.item_window
     
781.   end
     
782.   #--------------------------------------------------------------------------
     
783.   # * New method: shift_input
     
784.   #--------------------------------------------------------------------------
     
785.   def shift_input
     
786.     battler = @input_battlers.last
     
787.     battler.actor? ? setup_action(battler) : setup_no_selection(battler)
     
788.   end
     
789.   #--------------------------------------------------------------------------
     
790.   # * New method: setup_action
     
791.   #--------------------------------------------------------------------------
     
792.   def setup_action(battler)
     
793.     return if scene_changing?
     
794.     return if SceneManager.scene.windows_active? && battler.inputable?
     
795.     return if battler.guard? && VE_ATB_REVERSE
     
796.     battler.inputable? ? setup_selection(battler) : setup_no_selection(battler)
     
797.   end
     
798.   #--------------------------------------------------------------------------
     
799.   # * New method: setup_selection
     
800.   #--------------------------------------------------------------------------
     
801.   def setup_selection(battler)
     
802.     @actor_index = battler.index
     
803.     battler.make_actions
     
804.     SceneManager.scene.start_actor_command_selection
     
805.     VE_ATB_SOUND.play if VE_ATB_SOUND
     
806.   end
     
807.   #--------------------------------------------------------------------------
     
808.   # * New method: setup_no_selection
     
809.   #--------------------------------------------------------------------------
     
810.   def setup_no_selection(battler)
     
811.     battler.turn_count += 1 if !battler.actor? && !battler.cast_action?
     
812.     battler.make_actions
     
813.     battler.setup_cast_action if battler.cast_action?
     
814.     @input_battlers.delete(battler)
     
815.     @active_members.push(battler)
     
816.     turn_start
     
817.   end
     
818.   #--------------------------------------------------------------------------
     
819.   # * New method: add_actor
     
820.   #--------------------------------------------------------------------------
     
821.   def add_actor(battler)
     
822.     return unless input_battlers?(battler)
     
823.     @input_battlers.delete(battler)
     
824.     @active_members.push(battler)
     
825.   end
     
826.   #--------------------------------------------------------------------------
     
827.   # * New method: active_battler?
     
828.   #--------------------------------------------------------------------------
     
829.   def active_battler?(battler)
     
830.     @active_members.include?(battler) || @action_battlers.include?(battler) ||
     
831.     @input_battlers.include?(battler) || battler.current_actor? ||
     
832.     active?(battler)
     
833.   end
     
834.   #--------------------------------------------------------------------------
     
835.   # * New method: input_battlers?
     
836.   #--------------------------------------------------------------------------
     
837.   def input_battlers?(battler)
     
838.     @input_battlers.include?(battler)
     
839.   end
     
840.   #--------------------------------------------------------------------------
     
841.   # * New method: all_battle_members
     
842.   #--------------------------------------------------------------------------
     
843.   def all_battle_members
     
844.     $game_party.members + $game_troop.members
     
845.   end
     
846.   #--------------------------------------------------------------------------
     
847.   # * New method: all_dead_members
     
848.   #--------------------------------------------------------------------------
     
849.   def all_dead_members
     
850.     $game_party.dead_members + $game_troop.dead_members
     
851.   end
     
852.   #--------------------------------------------------------------------------
     
853.   # * New method: delete_input
     
854.   #--------------------------------------------------------------------------
     
855.   def delete_input(battler)
     
856.     @input_battlers.delete(battler)
     
857.   end
     
858.   #--------------------------------------------------------------------------
     
859.   # * New method: clear_battler
     
860.   #--------------------------------------------------------------------------
     
861.   def clear_battler(battler)
     
862.     @input_battlers.delete(battler)
     
863.     @active_members.delete(battler)
     
864.   end
     
865.   #--------------------------------------------------------------------------
     
866.   # * New method: escaping?
     
867.   #--------------------------------------------------------------------------
     
868.   def escaping?
     
869.     @key_escaping
     
870.   end
     
871.   #--------------------------------------------------------------------------
     
872.   # * New method: party_escaping?
     
873.   #--------------------------------------------------------------------------
     
874.   def party_escaping?
     
875.     @party_escaping
     
876.   end
     
877.   #--------------------------------------------------------------------------
     
878.   # * New method: active?
     
879.   #--------------------------------------------------------------------------
     
880.   def active?(battler)
     
881.     $imported[:ve_animated_battle] && battler.poses.active?
     
882.   end
     
883.   #--------------------------------------------------------------------------
     
884.   # * New method: setup_atb_turn_speed
     
885.   #--------------------------------------------------------------------------
     
886.   def setup_atb_turn_speed
     
887.     case VE_ATB_TURN_COUNT
     
888.     when :battlers then all_dead_members.size
     
889.     when :actions  then VE_ATB_ACTION_COUNT
     
890.     when :time     then VE_ATB_TIME_COUNT
     
891.     end
     
892.   end
     
893.   #--------------------------------------------------------------------------
     
894.   # * New method: clear_dead_atb
     
895.   #--------------------------------------------------------------------------
     
896.   def clear_dead_atb
     
897.     all_dead_members.each do |battler|
     
898.       next unless active_battler?(battler)
     
899.       battler.atb = 0
     
900.       @active_members.delete(battler)
     
901.       @input_battlers.delete(battler)
     
902.       @action_battlers.delete(battler)
     
903.     end
     
904.   end
     
905.   #--------------------------------------------------------------------------
     
906.   # * New method: increase_atb_turn_count
     
907.   #--------------------------------------------------------------------------
     
908.   def increase_atb_turn_count(type)
     
909.     @atb_turn_count += $game_system.atb_speed if VE_ATB_TURN_COUNT == type
     
910.   end
     
911.   #--------------------------------------------------------------------------
     
912.   # * New method: setup_escape
     
913.   #--------------------------------------------------------------------------
     
914.   def setup_escape
     
915.     $game_party.members.each {|battler| delete_input(battler) }
     
916.     @party_escaping = true
     
917.   end
     
918.   #--------------------------------------------------------------------------
     
919.   # * New method: undo_escape
     
920.   #--------------------------------------------------------------------------
     
921.   def undo_escape
     
922.     @party_escaping = false
     
923.   end
     
924.   #--------------------------------------------------------------------------
     
925.   # * New method: turn_phase
     
926.   #--------------------------------------------------------------------------
     
927.   def turn_phase
     
928.     @phase = :turn
     
929.   end
     
930. end
     
931. 
     
932. #==============================================================================
     
933. # ** Game_System
     
934. #------------------------------------------------------------------------------
     
935. #  This class handles system-related data. Also manages vehicles and BGM, etc.
     
936. # The instance of this class is referenced by $game_system.
     
937. #==============================================================================
     
938. 
     
939. class Game_System
     
940.   #--------------------------------------------------------------------------
     
941.   # * Public Instance Variables
     
942.   #--------------------------------------------------------------------------
     
943.   attr_accessor :wait_mode
     
944.   attr_accessor :atb_speed
     
945.   #--------------------------------------------------------------------------
     
946.   # * Alias method: initialize
     
947.   #--------------------------------------------------------------------------
     
948.   alias :initialize_ve_active_time_battle :initialize
     
949.   def initialize
     
950.     initialize_ve_active_time_battle
     
951.     @wait_mode = VE_ATB_WAIT_MODE
     
952.     @atb_speed = VE_ATB_SPEED
     
953.   end
     
954. end
     
955. 
     
956. #==============================================================================
     
957. # ** Game_Action
     
958. #------------------------------------------------------------------------------
     
959. #  This class handles battle actions. This class is used within the
     
960. # Game_Battler class.
     
961. #==============================================================================
     
962. 
     
963. class Game_Action
     
964.   #--------------------------------------------------------------------------
     
965.   # * Alias method: prepare
     
966.   #--------------------------------------------------------------------------
     
967.   alias :prepare_ve_active_time_battle :prepare
     
968.   def prepare
     
969.     subject.atb = item ? subject.atb * item.atb_cost : 0
     
970.     if item && item.castable? && !subject.cast_action? &&
     
971.        !subject.confusion? && !forcing
     
972.       subject.cast_action = self.clone
     
973.       subject.skip_actions
     
974.       subject.reset_pose if $imported[:ve_animated_battle]
     
975.     else
     
976.       subject.cast_action = nil if !forcing
     
977.       prepare_ve_active_time_battle
     
978.     end
     
979.   end
     
980. end
     
981. 
     
982. #==============================================================================
     
983. # ** Game_BattlerBase
     
984. #------------------------------------------------------------------------------
     
985. #  This class handles battlers. It's used as a superclass of the Game_Battler
     
986. # classes.
     
987. #==============================================================================
     
988. 
     
989. class Game_BattlerBase
     
990.   #--------------------------------------------------------------------------
     
991.   # * Alias method: inputable?
     
992.   #--------------------------------------------------------------------------
     
993.   alias :inputable_ve_active_time_battle? :inputable?
     
994.   def inputable?
     
995.     inputable_ve_active_time_battle? && atb_full? && input? && !cast_action?
     
996.   end
     
997.   #--------------------------------------------------------------------------
     
998.   # * Alias method: clear_states
     
999.   #--------------------------------------------------------------------------  
     
1000.   alias :clear_states_ve_active_time_battle :clear_states
      
1001.   def clear_states
      
1002.     clear_states_ve_active_time_battle
      
1003.     @state_timing = {}
      
1004.   end
      
1005.   #--------------------------------------------------------------------------
      
1006.   # * Alias method: erase_state
      
1007.   #--------------------------------------------------------------------------
      
1008.   alias :erase_state_ve_active_time_battle :erase_state
      
1009.   def erase_state(state_id)
      
1010.     erase_state_ve_active_time_battle(state_id)
      
1011.     @state_timing.delete(state_id)
      
1012.   end
      
1013. end
      
1014. 
      
1015. #==============================================================================
      
1016. # ** Game_Battler
      
1017. #------------------------------------------------------------------------------
      
1018. #  This class deals with battlers. It's used as a superclass of the Game_Actor
      
1019. # and Game_Enemy classes.
      
1020. #==============================================================================
      
1021. 
      
1022. class Game_Battler < Game_BattlerBase
      
1023.   #--------------------------------------------------------------------------
      
1024.   # * Public Instance Variables
      
1025.   #--------------------------------------------------------------------------
      
1026.   attr_accessor :cast_action
      
1027.   #--------------------------------------------------------------------------
      
1028.   # * Overwite method: on_action_end
      
1029.   #--------------------------------------------------------------------------
      
1030.   def on_action_end
      
1031.     @result.clear
      
1032.     regenerate_all if VE_ATB_REGEN_TRIGGER == :action
      
1033.     @result.clear  if VE_ATB_REGEN_TRIGGER == :action
      
1034.     remove_states_auto(1)
      
1035.     update_buff_turns
      
1036.     remove_buffs_auto
      
1037.   end
      
1038.   #--------------------------------------------------------------------------
      
1039.   # * Overwite method: on_turn_end
      
1040.   #--------------------------------------------------------------------------
      
1041.   def on_turn_end
      
1042.     @result.clear
      
1043.     remove_states_auto(2)
      
1044.   end
      
1045.   #--------------------------------------------------------------------------
      
1046.   # * Alias method: remove_states_auto
      
1047.   #--------------------------------------------------------------------------
      
1048.   alias :remove_states_auto_ve_active_time_battle :remove_states_auto
      
1049.   def remove_states_auto(timing)
      
1050.     update_state_auto(timing)
      
1051.     remove_states_auto_ve_active_time_battle(timing)
      
1052.   end
      
1053.   #--------------------------------------------------------------------------
      
1054.   # * Alias method: item_user_effect
      
1055.   #--------------------------------------------------------------------------
      
1056.   alias :item_user_effect_ve_active_time_battle :item_user_effect
      
1057.   def item_user_effect(user, item)
      
1058.     item_user_effect_ve_active_time_battle(user, item)
      
1059.     setup_cast_cancel(user, item)
      
1060.     setup_atb_delay(user, item)
      
1061.   end
      
1062.   #--------------------------------------------------------------------------
      
1063.   # * Alias method: reset_state_counts
      
1064.   #--------------------------------------------------------------------------
      
1065.   alias :reset_state_counts_ve_active_time_battle :reset_state_counts
      
1066.   def reset_state_counts(state_id)
      
1067.     reset_state_counts_ve_active_time_battle(state_id)
      
1068.     state = $data_states[state_id]
      
1069.     @state_timing[state_id] = state.timed_trigger if state.timed_trigger
      
1070.   end
      
1071.   #--------------------------------------------------------------------------
      
1072.   # * New method: max_atb
      
1073.   #--------------------------------------------------------------------------
      
1074.   def max_atb
      
1075.     @max_atb ||= 1000
      
1076.   end
      
1077.   #--------------------------------------------------------------------------
      
1078.   # * New method: atb
      
1079.   #--------------------------------------------------------------------------
      
1080.   def atb
      
1081.     @atb ||= 0
      
1082.   end
      
1083.   #--------------------------------------------------------------------------
      
1084.   # * New method: atb=
      
1085.   #--------------------------------------------------------------------------
      
1086.   def atb=(n)
      
1087.     @atb = [[n, 0].max, max_atb].min
      
1088.   end
      
1089.   #--------------------------------------------------------------------------
      
1090.   # * New method: atb_freeze
      
1091.   #--------------------------------------------------------------------------
      
1092.   def atb_freeze
      
1093.     @atb_freeze
      
1094.   end
      
1095.   #--------------------------------------------------------------------------
      
1096.   # * New method: regen_timing
      
1097.   #--------------------------------------------------------------------------
      
1098.   def regen_timing
      
1099.     @regen_timing ||= 0
      
1100.   end
      
1101.   #--------------------------------------------------------------------------
      
1102.   # * New method: regen_timing=
      
1103.   #--------------------------------------------------------------------------
      
1104.   def regen_timing=(n)
      
1105.     @regen_timing = [[n, 0].max, VE_ATB_REGEN_TIMING].min
      
1106.   end
      
1107.   #--------------------------------------------------------------------------
      
1108.   # * New method: regen_timing_full?
      
1109.   #--------------------------------------------------------------------------
      
1110.   def regen_timing_full?
      
1111.     regen_timing == VE_ATB_REGEN_TIMING
      
1112.   end
      
1113.   #--------------------------------------------------------------------------
      
1114.   # * New method: atb_freeze=
      
1115.   #--------------------------------------------------------------------------
      
1116.   def atb_freeze=(n)
      
1117.     @atb_freeze = n
      
1118.   end
      
1119.   #--------------------------------------------------------------------------
      
1120.   # * New method: atb_full?
      
1121.   #--------------------------------------------------------------------------
      
1122.   def atb_full?
      
1123.     @atb == max_atb
      
1124.   end
      
1125.   #--------------------------------------------------------------------------
      
1126.   # * New method: atb_rate
      
1127.   #--------------------------------------------------------------------------
      
1128.   def atb_rate
      
1129.     atb.to_f / max_atb
      
1130.   end
      
1131.   #--------------------------------------------------------------------------
      
1132.   # * New method: ready?
      
1133.   #--------------------------------------------------------------------------
      
1134.   def ready?
      
1135.     movable? && atb_full? && !active_battler?
      
1136.   end
      
1137.   #--------------------------------------------------------------------------
      
1138.   # * New method: cast_action?
      
1139.   #--------------------------------------------------------------------------
      
1140.   def cast_action?
      
1141.     cast_action ? true : false
      
1142.   end
      
1143.   #--------------------------------------------------------------------------
      
1144.   # * New method: preset_atb
      
1145.   #--------------------------------------------------------------------------
      
1146.   def preset_atb
      
1147.     self.atb = max_atb * VE_ATB_START_RATE * rand / 100
      
1148.   end
      
1149.   #--------------------------------------------------------------------------
      
1150.   # * New method: total_agi
      
1151.   #--------------------------------------------------------------------------
      
1152.   def total_agi
      
1153.     SceneManager.scene.all_battle_members.inject(0.0) {|r, obj| r += obj.agi }
      
1154.   end
      
1155.   #--------------------------------------------------------------------------
      
1156.   # * New method: atb_update
      
1157.   #--------------------------------------------------------------------------
      
1158.   def atb_update
      
1159.     update_atb_freeze if atb_freeze?
      
1160.     return if atb_wait?
      
1161.     self.atb_freeze = nil
      
1162.     self.atb += update_atb
      
1163.     self.atb  = max_atb if VE_ATB_REVERSE && !cast_action?
      
1164.   end
      
1165.   #--------------------------------------------------------------------------
      
1166.   # * New method: atb_freeze?
      
1167.   #--------------------------------------------------------------------------
      
1168.   def atb_freeze?
      
1169.     !movable?
      
1170.   end
      
1171.   #--------------------------------------------------------------------------
      
1172.   # * New method: update_atb
      
1173.   #--------------------------------------------------------------------------
      
1174.   def update_atb
      
1175.     speed = cast_action? ? cast_speed : agi
      
1176.     20.0 * $game_system.atb_speed * atb_speed_mod(speed) * speed_modifier
      
1177.   end
      
1178.   #--------------------------------------------------------------------------
      
1179.   # * New method: atb_wait?
      
1180.   #--------------------------------------------------------------------------
      
1181.   def atb_wait?
      
1182.     atb_full? || atb_freeze? || pause_damage? || current_actor? ||
      
1183.     (actor? && BattleManager.escaping?)
      
1184.   end
      
1185.   #--------------------------------------------------------------------------
      
1186.   # * New method: update_atb_freeze
      
1187.   #--------------------------------------------------------------------------
      
1188.   def update_atb_freeze
      
1189.     self.cast_action = nil
      
1190.     self.atb_freeze ||= self.atb
      
1191.     self.atb_freeze  += update_atb
      
1192.     atb_freeze_result unless @atb_freeze < max_atb
      
1193.   end
      
1194.   #--------------------------------------------------------------------------
      
1195.   # * New method: atb_freeze_result
      
1196.   #--------------------------------------------------------------------------
      
1197.   def atb_freeze_result
      
1198.     @result.clear
      
1199.     remove_states_auto(1)
      
1200.     regenerate_all if VE_ATB_REGEN_TRIGGER == :action
      
1201.     self.atb_freeze = 0
      
1202.   end
      
1203.   #--------------------------------------------------------------------------
      
1204.   # * New method: pause_damage?
      
1205.   #--------------------------------------------------------------------------
      
1206.   def pause_damage?
      
1207.     VE_ATB_DAMAGE_WAIT && $imported[:ve_animated_battle] && poses.damage_pose?
      
1208.   end
      
1209.   #--------------------------------------------------------------------------
      
1210.   # * New method: cast_speed
      
1211.   #--------------------------------------------------------------------------
      
1212.   def cast_speed
      
1213.     return agi if !cast_action
      
1214.     speed = cast_action.item.cast_speed
      
1215.     speed[:spd] * send(make_symbol(speed[:stat])) / 100.0
      
1216.   end
      
1217.   #--------------------------------------------------------------------------
      
1218.   # * New method: atb_speed_mod
      
1219.   #--------------------------------------------------------------------------
      
1220.   def atb_speed_mod(speed)
      
1221.     (speed + [VE_speed_modifier, 0].max) / total_agi
      
1222.   end
      
1223.   #--------------------------------------------------------------------------
      
1224.   # * New method: setup_cast_action
      
1225.   #--------------------------------------------------------------------------
      
1226.   def setup_cast_action
      
1227.     @actions = [cast_action]
      
1228.   end
      
1229.   #--------------------------------------------------------------------------
      
1230.   # * New method: setup_cast_cancel
      
1231.   #--------------------------------------------------------------------------
      
1232.   def setup_cast_cancel(user, item)
      
1233.     rate  = item.cast_cancel
      
1234.     rate += user.cast_cancel if item.physical?
      
1235.     rate *= cast_protection
      
1236.     execute_cast_cancel      if rand < rate && cast_action?
      
1237.   end
      
1238.   #--------------------------------------------------------------------------
      
1239.   # * New method: setup_atb_delay
      
1240.   #--------------------------------------------------------------------------
      
1241.   def setup_atb_delay(user, item)
      
1242.     rate  = item.atb_delay[:rate]
      
1243.     rate += user.atb_delay[:rate] if item.physical?
      
1244.     rate *= delay_protection
      
1245.     execute_atb_delay(user, item) if rand < rate
      
1246.   end
      
1247.   #--------------------------------------------------------------------------
      
1248.   # * New method: execute_cast_cancel
      
1249.   #--------------------------------------------------------------------------
      
1250.   def execute_cast_cancel
      
1251.     skip_actions
      
1252.     self.atb = 0
      
1253.     self.cast_action = nil
      
1254.   end
      
1255.   #--------------------------------------------------------------------------
      
1256.   # * New method: execute_atb_delay
      
1257.   #--------------------------------------------------------------------------
      
1258.   def execute_atb_delay(user, item)
      
1259.     rate  = item.atb_delay[:delay]
      
1260.     rate += user.atb_delay[:delay] if item.physical?
      
1261.     self.atb -= max_atb * rate
      
1262.   end
      
1263.   #--------------------------------------------------------------------------
      
1264.   # * New method: cast_cancel
      
1265.   #--------------------------------------------------------------------------
      
1266.   def cast_cancel
      
1267.     regexp = /<CAST CANCEL: (\d+)%?>/i
      
1268.     get_all_notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
      
1269.   end
      
1270.   #--------------------------------------------------------------------------
      
1271.   # * New method: atb_delay
      
1272.   #--------------------------------------------------------------------------
      
1273.   def atb_delay
      
1274.     result = {}
      
1275.     notes  = get_all_notes.dup
      
1276.     regexp = /<ATB DELAY: (\d+)%?, *(\d+)%?>/i
      
1277.     result[:rate]  = notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
      
1278.     result[:delay] = notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
      
1279.     result
      
1280.   end
      
1281.   #--------------------------------------------------------------------------
      
1282.   # * New method: cast_protection
      
1283.   #--------------------------------------------------------------------------
      
1284.   def cast_protection
      
1285.     regexp = /<CAST PROTECTION: (\d+)%?>/i
      
1286.     get_all_notes.scan(regexp).inject(1.0) {|r| r *= 1 - ($1.to_f / 100) }
      
1287.   end
      
1288.   #--------------------------------------------------------------------------
      
1289.   # * New method: delay_protection
      
1290.   #--------------------------------------------------------------------------
      
1291.   def delay_protection
      
1292.     regexp = /<DELAY PROTECTION: (\d+)%?>/i
      
1293.     get_all_notes.scan(regexp).inject(1.0) {|r| r *= 1 - ($1.to_f / 100) }
      
1294.   end
      
1295.   #--------------------------------------------------------------------------
      
1296.   # * New method: update_state_auto
      
1297.   #--------------------------------------------------------------------------
      
1298.   def update_state_auto(timing)
      
1299.     states.each do |state|
      
1300.       if @state_turns[state.id] > 0 && state.auto_removal_timing == timing
      
1301.         @state_turns[state.id] -= 1
      
1302.       end
      
1303.     end
      
1304.   end
      
1305.   #--------------------------------------------------------------------------
      
1306.   # * New method: on_timing
      
1307.   #--------------------------------------------------------------------------
      
1308.   def on_timing
      
1309.     timing_regen
      
1310.     remove_timing_states
      
1311.   end
      
1312.   #--------------------------------------------------------------------------
      
1313.   # * New method: timing_regen
      
1314.   #--------------------------------------------------------------------------
      
1315.   def timing_regen
      
1316.     return unless VE_ATB_REGEN_TRIGGER == :timing
      
1317.     self.regen_timing += $game_system.atb_speed if regen?
      
1318.     @result.clear     if regen_timing_full?
      
1319.     regenerate_all    if regen_timing_full?
      
1320.     @regen_timing = 0 if regen_timing_full? || !regen?
      
1321.   end
      
1322.   #--------------------------------------------------------------------------
      
1323.   # * New method: remove_timing_states
      
1324.   #--------------------------------------------------------------------------
      
1325.   def remove_timing_states
      
1326.     states.each do |state|
      
1327.       next if state.auto_removal_timing != 3
      
1328.       next if state.guard_state? && !VE_ATB_REVERSE
      
1329.       @state_timing[state.id] -= $game_system.atb_speed
      
1330.       if @state_turns[state.id] > 0 && @state_timing[state.id] <= 0
      
1331.         @state_turns[state.id] -= 1
      
1332.         @state_timing[state.id] = state.timed_trigger
      
1333.       end
      
1334.       remove_state(state.id) if @state_turns[state.id] == 0
      
1335.     end
      
1336.   end
      
1337.   #--------------------------------------------------------------------------
      
1338.   # * New method: regen?
      
1339.   #--------------------------------------------------------------------------
      
1340.   def regen?
      
1341.     hrg != 0 || mrg != 0 || trg != 0
      
1342.   end
      
1343.   #--------------------------------------------------------------------------
      
1344.   # * Overwite method: on_action_end
      
1345.   #--------------------------------------------------------------------------
      
1346.   def on_action_start
      
1347.     make_actions
      
1348.     remove_guard_state
      
1349.   end
      
1350.   #--------------------------------------------------------------------------
      
1351.   # * Overwite method: remove_guard_state
      
1352.   #--------------------------------------------------------------------------
      
1353.   def remove_guard_state
      
1354.     return if VE_ATB_REVERSE
      
1355.     states.each do |state|
      
1356.       next unless state.guard_state?
      
1357.       remove_state(state.id)
      
1358.       @damaged = true
      
1359.     end
      
1360.   end
      
1361.   #--------------------------------------------------------------------------
      
1362.   # * New method: skip_actions
      
1363.   #--------------------------------------------------------------------------
      
1364.   def skip_actions
      
1365.     clear_actions
      
1366.     @actions = [Game_Action.new(self)]
      
1367.   end
      
1368.   #--------------------------------------------------------------------------
      
1369.   # * New method: active_battler?
      
1370.   #--------------------------------------------------------------------------
      
1371.   def active_battler?
      
1372.     BattleManager.active_battler?(self)
      
1373.   end
      
1374.   #--------------------------------------------------------------------------
      
1375.   # * New method: input?
      
1376.   #--------------------------------------------------------------------------
      
1377.   def input?
      
1378.     BattleManager.input_battlers?(self)
      
1379.   end
      
1380.   #--------------------------------------------------------------------------
      
1381.   # * New method: current_actor?
      
1382.   #--------------------------------------------------------------------------
      
1383.   def current_actor?
      
1384.     SceneManager.scene_is?(Scene_Battle) && SceneManager.scene.subject == self
      
1385.   end
      
1386. end
      
1387. 
      
1388. #==============================================================================
      
1389. # ** Game_Actor
      
1390. #------------------------------------------------------------------------------
      
1391. #  This class handles actors. It's used within the Game_Actors class
      
1392. # ($game_actors) and referenced by the Game_Party class ($game_party).
      
1393. #==============================================================================
      
1394. 
      
1395. class Game_Actor < Game_Battler
      
1396.   #--------------------------------------------------------------------------
      
1397.   # * New method: speed_modifier
      
1398.   #--------------------------------------------------------------------------
      
1399.   def speed_modifier
      
1400.     list = [self.actor] + [self.class] + states + equips
      
1401.     list.compact.inject(1.0) {|r, obj| r *= obj.atb_speed }
      
1402.   end
      
1403. end
      
1404. 
      
1405. #==============================================================================
      
1406. # ** Game_Enemy
      
1407. #------------------------------------------------------------------------------
      
1408. #  This class handles enemy characters. It's used within the Game_Troop class
      
1409. # ($game_troop).
      
1410. #==============================================================================
      
1411. 
      
1412. class Game_Enemy < Game_Battler
      
1413.   #--------------------------------------------------------------------------
      
1414.   # * Public Instance Variables
      
1415.   #--------------------------------------------------------------------------
      
1416.   attr_accessor :turn_count
      
1417.   #--------------------------------------------------------------------------
      
1418.   # * Overwrite method: conditions_met_turns?
      
1419.   #--------------------------------------------------------------------------
      
1420.   def conditions_met_turns?(param1, param2)
      
1421.     n = @turn_count
      
1422.     if param2 == 0
      
1423.       n == param1
      
1424.     else
      
1425.       n > 0 && n >= param1 && n % param2 == param1 % param2
      
1426.     end
      
1427.   end
      
1428.   #--------------------------------------------------------------------------
      
1429.   # * Alias method: initialize
      
1430.   #--------------------------------------------------------------------------
      
1431.   alias :initialize_ve_active_time_battle :initialize
      
1432.   def initialize(index, enemy_id)
      
1433.     initialize_ve_active_time_battle(index, enemy_id)
      
1434.     @turn_count = 0
      
1435.   end
      
1436.   #--------------------------------------------------------------------------
      
1437.   # * New method: speed_modifier
      
1438.   #--------------------------------------------------------------------------
      
1439.   def speed_modifier
      
1440.     enemy.atb_speed * states.inject(1.0) {|r, state| r *= state.atb_speed }
      
1441.   end
      
1442. end
      
1443. 
      
1444. #==============================================================================
      
1445. # ** Spriteset_Battle
      
1446. #------------------------------------------------------------------------------
      
1447. #  This class brings together battle screen sprites. It's used within the
      
1448. # Scene_Battle class.
      
1449. #==============================================================================
      
1450. 
      
1451. class Spriteset_Battle
      
1452.   #--------------------------------------------------------------------------
      
1453.   # * Alias method: update_actors
      
1454.   #--------------------------------------------------------------------------
      
1455.   alias :update_actors_ve_active_time_battle :update_actors
      
1456.   def update_actors
      
1457.     uptate_actors_atb
      
1458.     update_actors_ve_active_time_battle
      
1459.   end
      
1460.   #--------------------------------------------------------------------------
      
1461.   # * New method: uptate_actors_atb
      
1462.   #--------------------------------------------------------------------------
      
1463.   def uptate_actors_atb
      
1464.     return if @atb_actors == $game_party.members
      
1465.     $game_party.members.each do |actor|
      
1466.       actor.preset_atb if @atb_actors && !@atb_actors.include?(actor)
      
1467.     end
      
1468.     @atb_actors = $game_party.members.dup
      
1469.   end
      
1470. end
      
1471. 
      
1472. #==============================================================================
      
1473. # ** Window_Base
      
1474. #------------------------------------------------------------------------------
      
1475. #  This is a superclass of all windows in the game.
      
1476. #==============================================================================
      
1477. 
      
1478. class Window_Base < Window
      
1479.   #--------------------------------------------------------------------------
      
1480.   # * Public Instance Variables
      
1481.   #--------------------------------------------------------------------------
      
1482.   attr_accessor :hidden
      
1483. end
      
1484. 
      
1485. #==============================================================================
      
1486. # ** Window_BattleLog
      
1487. #------------------------------------------------------------------------------
      
1488. #  This window shows the battle progress. Do not show the window frame.
      
1489. #==============================================================================
      
1490. 
      
1491. class Window_BattleLog < Window_Selectable
      
1492.   #--------------------------------------------------------------------------
      
1493.   # * Alias method: last_text
      
1494.   #--------------------------------------------------------------------------
      
1495.   alias :last_text_ve_active_time_battle :last_text
      
1496.   def last_text
      
1497.     last_text_ve_active_time_battle ? last_text_ve_active_time_battle : ""
      
1498.   end
      
1499. end
      
1500. 
      
1501. #==============================================================================
      
1502. # ** Window_ActorCommand
      
1503. #------------------------------------------------------------------------------
      
1504. #  This window is used to select actor commands, such as "Attack" or "Skill".
      
1505. #==============================================================================
      
1506. 
      
1507. class Window_ActorCommand < Window_Command
      
1508.   #--------------------------------------------------------------------------
      
1509.   # * Alias method: make_command_list
      
1510.   #--------------------------------------------------------------------------
      
1511.   alias :make_command_list_ve_active_time_battle :make_command_list
      
1512.   def make_command_list
      
1513.     make_command_list_ve_active_time_battle
      
1514.     add_escape_command if VE_ATB_ESCAPE_TYPE == :command
      
1515.   end
      
1516.   #--------------------------------------------------------------------------
      
1517.   # * New method: add_escape_command
      
1518.   #--------------------------------------------------------------------------
      
1519.   def add_escape_command
      
1520.     add_command(Vocab::escape, :escape, BattleManager.can_escape?)
      
1521.   end
      
1522. end
      
1523. 
      
1524. #==============================================================================
      
1525. # ** Window_BattleStatus
      
1526. #------------------------------------------------------------------------------
      
1527. #  Esta janela exibe as condições de todos membros do grupo na tela de batalha.
      
1528. #==============================================================================
      
1529. 
      
1530. class Window_BattleStatus < Window_Selectable
      
1531.   #--------------------------------------------------------------------------
      
1532.   # * Overwrite method: window_width
      
1533.   #--------------------------------------------------------------------------
      
1534.   def window_width
      
1535.     Graphics.width - ($data_system.opt_display_tp ? 0 : 128)
      
1536.   end
      
1537.   #--------------------------------------------------------------------------
      
1538.   # * Overwrite method: draw_basic_area
      
1539.   #--------------------------------------------------------------------------
      
1540.   def draw_basic_area(rect, actor)
      
1541.     width = $data_system.opt_display_tp ? 180 : 104
      
1542.     draw_actor_name(actor, rect.x + 0, rect.y, 100)
      
1543.     draw_actor_icons(actor, rect.x + 104, rect.y, [rect.width - width, 24].max)
      
1544.   end
      
1545.   #--------------------------------------------------------------------------
      
1546.   # * Overwrite method: draw_gauge_area_with_tp
      
1547.   #--------------------------------------------------------------------------
      
1548.   def draw_gauge_area_with_tp(rect, actor)
      
1549.     draw_actor_hp(actor, rect.x - 82, rect.y, 72)
      
1550.     draw_actor_mp(actor, rect.x + 0, rect.y, 64)
      
1551.     draw_actor_tp(actor, rect.x + 74, rect.y, 64)
      
1552.     update_atb
      
1553.   end
      
1554.   #--------------------------------------------------------------------------
      
1555.   # * Overwrite method: draw_gauge_area_without_tp
      
1556.   #--------------------------------------------------------------------------
      
1557.   def draw_gauge_area_without_tp(rect, actor)
      
1558.     draw_actor_hp(actor, rect.x + 0, rect.y, 72)
      
1559.     draw_actor_mp(actor, rect.x + 82, rect.y, 64)
      
1560.     update_atb
      
1561.   end
      
1562.   #--------------------------------------------------------------------------
      
1563.   # * Overwrite method: update
      
1564.   #--------------------------------------------------------------------------
      
1565.   def update
      
1566.     super
      
1567.     update_atb
      
1568.   end
      
1569.   #--------------------------------------------------------------------------
      
1570.   # * New method: update_atb
      
1571.   #--------------------------------------------------------------------------
      
1572.   def update_atb
      
1573.     @count ||= 0
      
1574.     @count  += 1
      
1575.     return if @count % 2 != 0
      
1576.     update_atb_bars
      
1577.   end
      
1578.   #--------------------------------------------------------------------------
      
1579.   # * New method: update_atb_bars
      
1580.   #--------------------------------------------------------------------------
      
1581.   def update_atb_bars
      
1582.     tp_adjust = $data_system.opt_display_tp ? 148 : 156
      
1583.     item_max.times do |i|
      
1584.       actor = $game_party.battle_members[i]
      
1585.       rect  = gauge_area_rect(i)
      
1586.       rect.x += tp_adjust
      
1587.       contents.clear_rect(rect)
      
1588.       draw_actor_atb(actor, rect.x, rect.y, 64)
      
1589.     end
      
1590.   end
      
1591.   #--------------------------------------------------------------------------
      
1592.   # * New method: draw_actor_atb
      
1593.   #--------------------------------------------------------------------------
      
1594.   def draw_actor_atb(actor, x, y, width = 124)
      
1595.     color1 = setup_atb_color1(actor)
      
1596.     color2 = setup_atb_color2(actor)
      
1597.     draw_gauge(x, y, width, actor.atb_rate, color1, color2)
      
1598.     change_color(system_color)
      
1599.     draw_text(x, y, 30, line_height, Vocab::VE_ATB_Name)
      
1600.   end
      
1601.   #--------------------------------------------------------------------------
      
1602.   # * New method: setup_atb_color1
      
1603.   #--------------------------------------------------------------------------
      
1604.   def setup_atb_color1(actor)
      
1605.     return text_color(2) if actor.cast_action?
      
1606.     return text_color(6) if BattleManager.party_escaping?
      
1607.     return text_color(5)
      
1608.   end
      
1609.   #--------------------------------------------------------------------------
      
1610.   # * New method: setup_atb_color2
      
1611.   #--------------------------------------------------------------------------
      
1612.   def setup_atb_color2(actor)
      
1613.     return text_color(10) if actor.cast_action?
      
1614.     return text_color(14) if BattleManager.party_escaping?
      
1615.     return text_color(13)
      
1616.   end
      
1617. end
      
1618. 
      
1619. #==============================================================================
      
1620. # ** Scene_Battle
      
1621. #------------------------------------------------------------------------------
      
1622. #  This class performs battle screen processing.
      
1623. #==============================================================================
      
1624. 
      
1625. class Scene_Battle < Scene_Base
      
1626.   #--------------------------------------------------------------------------
      
1627.   # * Public Instance Variables
      
1628.   #--------------------------------------------------------------------------
      
1629.   attr_reader   :log_window
      
1630.   attr_reader   :item_window
      
1631.   attr_reader   :skill_window
      
1632.   #--------------------------------------------------------------------------
      
1633.   # * Overwrite method: update_info_viewport
      
1634.   #--------------------------------------------------------------------------
      
1635.   def update_all_windows
      
1636.     update_active_windows
      
1637.     super
      
1638.   end
      
1639.   #--------------------------------------------------------------------------
      
1640.   # * Overwrite method: update_info_viewport
      
1641.   #--------------------------------------------------------------------------
      
1642.   def update_info_viewport
      
1643.     if VE_MOVE_STATUS_WINDOW
      
1644.       @move_info_wait  = 4 if @moved_info != windows_active?
      
1645.       @move_info_wait -= 1
      
1646.       move_info_viewport(0) if @party_command_window.active
      
1647.       move_info_viewport(right_status_window)  if right_info_viewport
      
1648.       move_info_viewport(center_status_window) if center_info_viewport
      
1649.       @moved_info = windows_active?
      
1650.     else
      
1651.       move_info_viewport(128)
      
1652.     end
      
1653.     update_close_command_window
      
1654.   end
      
1655.   #--------------------------------------------------------------------------
      
1656.   # * Overwrite method: turn_start
      
1657.   #--------------------------------------------------------------------------
      
1658.   def turn_start
      
1659.     BattleManager.add_actor(BattleManager.actor)
      
1660.     @close_command_wait   = 2
      
1661.     @close_command_window = true
      
1662.     @status_window.unselect
      
1663.     BattleManager.turn_start
      
1664.   end
      
1665.   #--------------------------------------------------------------------------
      
1666.   # * Overwrite method: start_party_command_selection
      
1667.   #--------------------------------------------------------------------------
      
1668.   def start_party_command_selection
      
1669.   end
      
1670.   #--------------------------------------------------------------------------
      
1671.   # * Overwrite method: turn_end
      
1672.   #--------------------------------------------------------------------------
      
1673.   def turn_end
      
1674.   end
      
1675.   #--------------------------------------------------------------------------
      
1676.   # * Alias method: battle_start
      
1677.   #--------------------------------------------------------------------------
      
1678.   alias :battle_start_ve_active_time_battle :battle_start
      
1679.   def battle_start
      
1680.     battle_start_ve_active_time_battle
      
1681.     battle_start_open_window
      
1682.   end
      
1683.   #--------------------------------------------------------------------------
      
1684.   # * Alias method: create_all_windows
      
1685.   #--------------------------------------------------------------------------
      
1686.   alias :create_all_windows_ve_active_time_battle :create_all_windows
      
1687.   def create_all_windows
      
1688.     create_all_windows_ve_active_time_battle
      
1689.     create_escape_window
      
1690.     @close_command_wait = 0
      
1691.     @move_info_wait     = 4
      
1692.   end
      
1693.   #--------------------------------------------------------------------------
      
1694.   # * Alias method: reate_party_command_window
      
1695.   #--------------------------------------------------------------------------
      
1696.   alias :create_party_command_window_ve_active_time_battle :create_party_command_window
      
1697.   def create_party_command_window
      
1698.     create_party_command_window_ve_active_time_battle
      
1699.     unless VE_MOVE_STATUS_WINDOW
      
1700.       @party_command_window.x = @party_command_window.width
      
1701.     end
      
1702.     @info_viewport.ox = center_status_window
      
1703.   end
      
1704.   #--------------------------------------------------------------------------
      
1705.   # * Alias method: create_actor_command_window
      
1706.   #--------------------------------------------------------------------------
      
1707.   alias :create_command_window_ve_active_time_battle :create_actor_command_window
      
1708.   def create_actor_command_window
      
1709.     create_command_window_ve_active_time_battle
      
1710.     @actor_command_window.set_handler(:escape,  method(:command_escape))
      
1711.     if !VE_MOVE_STATUS_WINDOW
      
1712.       @actor_command_window.x = @actor_command_window.width
      
1713.     elsif $data_system.opt_display_tp
      
1714.       @actor_command_window.x = Graphics.width + 128
      
1715.     end
      
1716.   end
      
1717.   #--------------------------------------------------------------------------
      
1718.   # * Alias method: update
      
1719.   #--------------------------------------------------------------------------
      
1720.   alias :update_ve_active_time_battle :update
      
1721.   def update
      
1722.     result = update_ve_active_time_battle
      
1723.     BattleManager.update_atb unless result
      
1724.     result
      
1725.   end
      
1726.   #--------------------------------------------------------------------------
      
1727.   # * Alias method: update_basic
      
1728.   #--------------------------------------------------------------------------
      
1729.   alias :update_basic_ve_active_time_battle :update_basic
      
1730.   def update_basic
      
1731.     update_basic_ve_active_time_battle
      
1732.     update_escape_window if VE_ATB_ESCAPE_TYPE == :key
      
1733.   end
      
1734.   #--------------------------------------------------------------------------
      
1735.   # * Alias method: update_for_wait
      
1736.   #--------------------------------------------------------------------------
      
1737.   alias :update_for_wait_ve_active_time_battle :update_for_wait
      
1738.   def update_for_wait
      
1739.     update_for_wait_ve_active_time_battle
      
1740.     BattleManager.update_atb if BattleManager.in_turn? && !wait_action?
      
1741.   end
      
1742.   #--------------------------------------------------------------------------
      
1743.   # * Alias method: wait_for_message
      
1744.   #--------------------------------------------------------------------------
      
1745.   alias :wait_for_message_ve_active_time_battle :wait_for_message
      
1746.   def wait_for_message
      
1747.     wait_for_message_ve_active_time_battle
      
1748.     open_windows
      
1749.   end
      
1750.   #--------------------------------------------------------------------------
      
1751.   # * Atualização da mensagem aberta
      
1752.   #--------------------------------------------------------------------------
      
1753.   alias :update_message_open_ve_active_time_battle :update_message_open
      
1754.   def update_message_open
      
1755.     close_windows
      
1756.     update_message_open_ve_active_time_battle
      
1757.   end
      
1758.   #--------------------------------------------------------------------------
      
1759.   # * Alias method: start_actor_command_selection
      
1760.   #--------------------------------------------------------------------------
      
1761.   alias :start_actor_command_selection_ve_active_time_battle :start_actor_command_selection
      
1762.   def start_actor_command_selection
      
1763.     start_actor_command_selection_ve_active_time_battle
      
1764.     @close_command_window = false
      
1765.   end
      
1766.   #--------------------------------------------------------------------------
      
1767.   # * Alias method: process_action_end
      
1768.   #--------------------------------------------------------------------------
      
1769.   alias :process_action_end_ve_active_time_battle :process_action_end
      
1770.   def process_action_end
      
1771.     return if $imported[:ve_animated_battle] && @subject.poses.active?
      
1772.     BattleManager.increase_atb_turn_count(:battlers)
      
1773.     BattleManager.increase_atb_turn_count(:actions)
      
1774.     process_action_end_ve_active_time_battle
      
1775.   end
      
1776.   #--------------------------------------------------------------------------
      
1777.   # * Alias method: command_fight
      
1778.   #--------------------------------------------------------------------------
      
1779.   alias :command_fight_end_ve_active_time_battle :command_fight
      
1780.   def command_fight
      
1781.     command_fight_end_ve_active_time_battle
      
1782.     @party_command_window.close
      
1783.     BattleManager.undo_escape
      
1784.   end
      
1785.   #--------------------------------------------------------------------------
      
1786.   # * Alias method: command_escape
      
1787.   #--------------------------------------------------------------------------
      
1788.   alias :command_escape_end_ve_active_time_battle :command_escape
      
1789.   def command_escape
      
1790.     if VE_ATB_ESCAPE_TYPE == :command
      
1791.       BattleManager.actor.atb = 0
      
1792.       command_escape_end_ve_active_time_battle
      
1793.       battle_start_open_window
      
1794.     else
      
1795.       @party_command_window.close
      
1796.       BattleManager.setup_escape
      
1797.     end
      
1798.   end
      
1799.   #--------------------------------------------------------------------------
      
1800.   # * Alias method: prior_command
      
1801.   #--------------------------------------------------------------------------
      
1802.   alias :prior_command_ve_active_time_battle :prior_command
      
1803.   def prior_command
      
1804.     prior_command_ve_active_time_battle
      
1805.     open_party_command_selection if !BattleManager.actor.prior_command
      
1806.   end
      
1807.   #--------------------------------------------------------------------------
      
1808.   # * Alias method: on_enemy_ok
      
1809.   #--------------------------------------------------------------------------
      
1810.   alias :on_enemy_ok_ve_active_time_battle :on_enemy_ok
      
1811.   def on_enemy_ok
      
1812.     return if !@enemy_window.enemy
      
1813.     on_enemy_ok_ve_active_time_battle
      
1814.   end
      
1815.   #--------------------------------------------------------------------------
      
1816.   # * Alias method: refresh_status
      
1817.   #--------------------------------------------------------------------------
      
1818.   alias :refresh_status_ve_active_time_battle :refresh_status
      
1819.   def refresh_status
      
1820.     refresh_status_ve_active_time_battle
      
1821.     @skill_window.refresh if @skill_window.active
      
1822.     @item_window.refresh  if @item_window.active
      
1823.   end
      
1824.   #--------------------------------------------------------------------------
      
1825.   # * New method: update_close_command_window
      
1826.   #--------------------------------------------------------------------------
      
1827.   def update_close_command_window
      
1828.     @close_command_wait -= 1
      
1829.     if @close_command_wait == 0 && @close_command_window
      
1830.       @actor_command_window.close
      
1831.       @close_command_window = false
      
1832.     end
      
1833.   end
      
1834.   #--------------------------------------------------------------------------
      
1835.   # * New method: update_active_windows
      
1836.   #--------------------------------------------------------------------------
      
1837.   def update_active_windows
      
1838.     @enemy_window.hide if @enemy_window.active && @enemy_window.item_max == 0
      
1839.     @actor_window.hide if @actor_window.active && @actor_window.item_max == 0
      
1840.     close_command_windows
      
1841.   end
      
1842.   #--------------------------------------------------------------------------
      
1843.   # * New method: close_command_windows
      
1844.   #--------------------------------------------------------------------------
      
1845.   def close_command_windows
      
1846.     return if !BattleManager.actor || BattleManager.actor.inputable?
      
1847.     on_enemy_cancel if @enemy_window.active
      
1848.     on_actor_cancel if @actor_window.active
      
1849.     on_skill_cancel if @skill_window.active
      
1850.     on_item_cancel  if @item_window.active
      
1851.     @actor_command_window.close.deactivate
      
1852.     @skill_window.deactivate
      
1853.     @item_window.deactivate
      
1854.     @actor_window.deactivate
      
1855.     @enemy_window.deactivate
      
1856.     BattleManager.clear_actor
      
1857.     next_command
      
1858.   end
      
1859.   #--------------------------------------------------------------------------
      
1860.   # * New method: create_escape_window
      
1861.   #--------------------------------------------------------------------------
      
1862.   def create_escape_window
      
1863.     @escape_window = Window_Help.new(1)
      
1864.     @escape_window.openness = 0
      
1865.   end
      
1866.   #--------------------------------------------------------------------------
      
1867.   # * New method: update_escape_window
      
1868.   #--------------------------------------------------------------------------
      
1869.   def update_escape_window
      
1870.     escaping = BattleManager.escaping?
      
1871.     open_escape_window   if  escaping && @escape_window.openness == 0
      
1872.     @escape_window.close if !escaping && @escape_window.openness != 0
      
1873.   end
      
1874.   #--------------------------------------------------------------------------
      
1875.   # * New method: open_escape_window
      
1876.   #--------------------------------------------------------------------------
      
1877.   def open_escape_window
      
1878.     return if BattleManager.can_escape? && !VE_ATB_ESCAPE_TEXT
      
1879.     txt = BattleManager.can_escape? ? Vocab::VE_Escaping : Vocab::VE_CantEscape
      
1880.     @escape_window.set_text(txt)
      
1881.     @escape_window.open
      
1882.   end
      
1883.   #--------------------------------------------------------------------------
      
1884.   # * New method: on_turn_end
      
1885.   #--------------------------------------------------------------------------
      
1886.   def on_turn_end
      
1887.   end
      
1888.   #--------------------------------------------------------------------------
      
1889.   # * New method: close_windows
      
1890.   #--------------------------------------------------------------------------
      
1891.   def close_windows
      
1892.     if $game_message.busy? && !@status_window.close?
      
1893.       command_windows.each {|window| window.hidden ||= window.open?  }
      
1894.       @help_window.close
      
1895.       @item_window.close
      
1896.       @skill_window.close
      
1897.       @actor_window.close
      
1898.       @enemy_window.close
      
1899.     end
      
1900.   end
      
1901.   #--------------------------------------------------------------------------
      
1902.   # * New method: open_windows
      
1903.   #--------------------------------------------------------------------------
      
1904.   def open_windows
      
1905.     command_windows.each do |window|
      
1906.       window.open if window.hidden
      
1907.       window.hidden = false
      
1908.     end
      
1909.   end
      
1910.   #--------------------------------------------------------------------------
      
1911.   # * New method: command_windows
      
1912.   #--------------------------------------------------------------------------
      
1913.   def command_windows
      
1914.     [@party_command_window, @actor_command_window, @help_window, @skill_window,
      
1915.      @item_window, @actor_window, @enemy_window, @status_window]
      
1916.   end
      
1917.   #--------------------------------------------------------------------------
      
1918.   # * New method: battle_start_open_window
      
1919.   #--------------------------------------------------------------------------
      
1920.   def battle_start_open_window
      
1921.     unless scene_changing?
      
1922.       refresh_status
      
1923.       @status_window.unselect
      
1924.       @status_window.open
      
1925.     end
      
1926.   end
      
1927.   #--------------------------------------------------------------------------
      
1928.   # * New method: open_party_command_selection
      
1929.   #--------------------------------------------------------------------------
      
1930.   def open_party_command_selection
      
1931.     return if scene_changing? || VE_ATB_ESCAPE_TYPE != :party
      
1932.     BattleManager.delete_input(BattleManager.actor)
      
1933.     refresh_status
      
1934.     @status_window.unselect
      
1935.     @status_window.open
      
1936.     @actor_command_window.close.deactivate
      
1937.     @party_command_window.setup
      
1938.   end
      
1939.   #--------------------------------------------------------------------------
      
1940.   # * New method: wait_action?
      
1941.   #--------------------------------------------------------------------------
      
1942.   def wait_action?
      
1943.     VE_ATB_WAIT_ACTION
      
1944.   end
      
1945.   #--------------------------------------------------------------------------
      
1946.   # * New method: full_wait?
      
1947.   #--------------------------------------------------------------------------
      
1948.   def full_wait?
      
1949.     $game_system.wait_mode == :full_wait && windows_active?(true)
      
1950.   end
      
1951.   #--------------------------------------------------------------------------
      
1952.   # * New method: semi_wait?
      
1953.   #--------------------------------------------------------------------------
      
1954.   def semi_wait?
      
1955.     $game_system.wait_mode == :semi_wait && windows_active?(false)
      
1956.   end
      
1957.   #--------------------------------------------------------------------------
      
1958.   # * New method: party_window?
      
1959.   #--------------------------------------------------------------------------
      
1960.   def party_window?
      
1961.     @party_command_window.active
      
1962.   end
      
1963.   #--------------------------------------------------------------------------
      
1964.   # * New method: windows_active?
      
1965.   #--------------------------------------------------------------------------
      
1966.   def windows_active?(command = true)
      
1967.     (command && @actor_command_window.active)   || @skill_window.active ||
      
1968.     @item_window.active || @actor_window.active || @enemy_window.active
      
1969.   end
      
1970.   #--------------------------------------------------------------------------
      
1971.   # * New method: turn_ending
      
1972.   #--------------------------------------------------------------------------
      
1973.   def turn_ending
      
1974.     BattleManager.turn_end
      
1975.     process_event
      
1976.     BattleManager.turn_phase
      
1977.   end
      
1978.   #--------------------------------------------------------------------------
      
1979.   # * New method: right_status_window
      
1980.   #--------------------------------------------------------------------------
      
1981.   def right_status_window
      
1982.     256 - (Graphics.width - @status_window.width)
      
1983.   end
      
1984.   #--------------------------------------------------------------------------
      
1985.   # * New method: center_status_window
      
1986.   #--------------------------------------------------------------------------
      
1987.   def center_status_window
      
1988.     128 - (Graphics.width - @status_window.width) / 2
      
1989.   end
      
1990.   #--------------------------------------------------------------------------
      
1991.   # * New method: right_info_viewport
      
1992.   #--------------------------------------------------------------------------
      
1993.   def right_info_viewport
      
1994.     !@party_command_window.active && windows_active? && @move_info_wait < 0
      
1995.   end
      
1996.   #--------------------------------------------------------------------------
      
1997.   # * New method: center_info_viewport
      
1998.   #--------------------------------------------------------------------------
      
1999.   def center_info_viewport
      
2000.     !@party_command_window.active && !windows_active? && @move_info_wait < 0
      
2001.   end
      
2002. end
      

复制代码

Vortur

可否给出进一步的信息，如：
1.脚本来源、使用说明
2.脚本发布时是否有范例
3.报错工程中是否有其它插件
其中1、2主要是找一个“可用的参考”，作为对照组；并找出可能的冲突或者设置上的失误


PS：
脚本可以使用“脚本框”框起来。这样可以使它在一定程度上被折叠，并且方便复制。不过会有一些bug，例如“@”后面通常会被论坛错误理解，导致自动增加一些字段，进而使脚本失效(或者其他未知bug)，此类信息可参考论坛使用说明。因此使用一个可以“保存格式”的txt文本编辑软件是十分重要的，推荐notepad++与UltraEdit,或者GeminiRelease。对于脚本的入门，推荐使用这个教程：https://rpg.blue/thread-315743-1-1.html