rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/SceneManager.rb

@@ -0,0 +1,94 @@
+#==============================================================================
+# ** SceneManager
+#------------------------------------------------------------------------------
+#  This module manages scene transitions. For example, it can handle
+# hierarchical structures such as calling the item screen from the main menu
+# or returning from the item screen to the main menu.
+#==============================================================================
+
+module SceneManager
+  #--------------------------------------------------------------------------
+  # * Module Instance Variables
+  #--------------------------------------------------------------------------
+  @scene = nil                            # current scene object
+  @stack = []                             # stack for hierarchical transitions
+  @background_bitmap = nil                # background bitmap
+  #--------------------------------------------------------------------------
+  # * Execute
+  #--------------------------------------------------------------------------
+  def self.run
+    DataManager.init
+    Audio.setup_midi if use_midi?
+    @scene = first_scene_class.new
+    @scene.main while @scene
+  end
+  #--------------------------------------------------------------------------
+  # * Get First Scene Class
+  #--------------------------------------------------------------------------
+  def self.first_scene_class
+    $BTEST ? Scene_Battle : Scene_Title
+  end
+  #--------------------------------------------------------------------------
+  # * Use MIDI?
+  #--------------------------------------------------------------------------
+  def self.use_midi?
+    $data_system.opt_use_midi
+  end
+  #--------------------------------------------------------------------------
+  # * Get Current Scene
+  #--------------------------------------------------------------------------
+  def self.scene
+    @scene
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Current Scene Class
+  #--------------------------------------------------------------------------
+  def self.scene_is?(scene_class)
+    @scene.instance_of?(scene_class)
+  end
+  #--------------------------------------------------------------------------
+  # * Direct Transition
+  #--------------------------------------------------------------------------
+  def self.goto(scene_class)
+    @scene = scene_class.new
+  end
+  #--------------------------------------------------------------------------
+  # * Call
+  #--------------------------------------------------------------------------
+  def self.call(scene_class)
+    @stack.push(@scene)
+    @scene = scene_class.new
+  end
+  #--------------------------------------------------------------------------
+  # * Return to Caller
+  #--------------------------------------------------------------------------
+  def self.return
+    @scene = @stack.pop
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Call Stack
+  #--------------------------------------------------------------------------
+  def self.clear
+    @stack.clear
+  end
+  #--------------------------------------------------------------------------
+  # * Exit Game
+  #--------------------------------------------------------------------------
+  def self.exit
+    @scene = nil
+  end
+  #--------------------------------------------------------------------------
+  # * Create Snapshot to Use as Background
+  #--------------------------------------------------------------------------
+  def self.snapshot_for_background
+    @background_bitmap.dispose if @background_bitmap
+    @background_bitmap = Graphics.snap_to_bitmap
+    @background_bitmap.blur
+  end
+  #--------------------------------------------------------------------------
+  # * Get Background Bitmap
+  #--------------------------------------------------------------------------
+  def self.background_bitmap
+    @background_bitmap
+  end
+end

data/lib/rgss3_default_scripts/Scene_Base.rb

@@ -0,0 +1,132 @@
+#==============================================================================
+# ** Scene_Base
+#------------------------------------------------------------------------------
+#  This is a super class of all scenes within the game.
+#==============================================================================
+
+class Scene_Base
+  #--------------------------------------------------------------------------
+  # * Main
+  #--------------------------------------------------------------------------
+  def main
+    start
+    post_start
+    update until scene_changing?
+    pre_terminate
+    terminate
+  end
+  #--------------------------------------------------------------------------
+  # * Start Processing
+  #--------------------------------------------------------------------------
+  def start
+    create_main_viewport
+  end
+  #--------------------------------------------------------------------------
+  # * Post-Start Processing
+  #--------------------------------------------------------------------------
+  def post_start
+    perform_transition
+    Input.update
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Scene Is Changing
+  #--------------------------------------------------------------------------
+  def scene_changing?
+    SceneManager.scene != self
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    update_basic
+  end
+  #--------------------------------------------------------------------------
+  # * Update Frame (Basic)
+  #--------------------------------------------------------------------------
+  def update_basic
+    Graphics.update
+    Input.update
+    update_all_windows
+  end
+  #--------------------------------------------------------------------------
+  # * Pre-Termination Processing
+  #--------------------------------------------------------------------------
+  def pre_terminate
+  end
+  #--------------------------------------------------------------------------
+  # * Termination Processing
+  #--------------------------------------------------------------------------
+  def terminate
+    Graphics.freeze
+    dispose_all_windows
+    dispose_main_viewport
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Transition
+  #--------------------------------------------------------------------------
+  def perform_transition
+    Graphics.transition(transition_speed)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Transition Speed
+  #--------------------------------------------------------------------------
+  def transition_speed
+    return 10
+  end
+  #--------------------------------------------------------------------------
+  # * Create Viewport
+  #--------------------------------------------------------------------------
+  def create_main_viewport
+    @viewport = Viewport.new
+    @viewport.z = 200
+  end
+  #--------------------------------------------------------------------------
+  # * Free Viewport
+  #--------------------------------------------------------------------------
+  def dispose_main_viewport
+    @viewport.dispose
+  end
+  #--------------------------------------------------------------------------
+  # * Update All Windows
+  #--------------------------------------------------------------------------
+  def update_all_windows
+    instance_variables.each do |varname|
+      ivar = instance_variable_get(varname)
+      ivar.update if ivar.is_a?(Window)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Free All Windows
+  #--------------------------------------------------------------------------
+  def dispose_all_windows
+    instance_variables.each do |varname|
+      ivar = instance_variable_get(varname)
+      ivar.dispose if ivar.is_a?(Window)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Return to Calling Scene
+  #--------------------------------------------------------------------------
+  def return_scene
+    SceneManager.return
+  end
+  #--------------------------------------------------------------------------
+  # * Fade Out All Sounds and Graphics
+  #--------------------------------------------------------------------------
+  def fadeout_all(time = 1000)
+    RPG::BGM.fade(time)
+    RPG::BGS.fade(time)
+    RPG::ME.fade(time)
+    Graphics.fadeout(time * Graphics.frame_rate / 1000)
+    RPG::BGM.stop
+    RPG::BGS.stop
+    RPG::ME.stop
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Game Is Over
+  #   Transition to the game over screen if the entire party is dead.
+  #--------------------------------------------------------------------------
+  def check_gameover
+    SceneManager.goto(Scene_Gameover) if $game_party.all_dead?
+  end
+end

data/lib/rgss3_default_scripts/Scene_Battle.rb

@@ -0,0 +1,693 @@
+#==============================================================================
+# ** Scene_Battle
+#------------------------------------------------------------------------------
+#  This class performs battle screen processing.
+#==============================================================================
+
+class Scene_Battle < Scene_Base
+  #--------------------------------------------------------------------------
+  # * Start Processing
+  #--------------------------------------------------------------------------
+  def start
+    super
+    create_spriteset
+    create_all_windows
+    BattleManager.method_wait_for_message = method(:wait_for_message)
+  end
+  #--------------------------------------------------------------------------
+  # * Post-Start Processing
+  #--------------------------------------------------------------------------
+  def post_start
+    super
+    battle_start
+  end
+  #--------------------------------------------------------------------------
+  # * Pre-Termination Processing
+  #--------------------------------------------------------------------------
+  def pre_terminate
+    super
+    Graphics.fadeout(30) if SceneManager.scene_is?(Scene_Map)
+    Graphics.fadeout(60) if SceneManager.scene_is?(Scene_Title)
+  end
+  #--------------------------------------------------------------------------
+  # * Termination Processing
+  #--------------------------------------------------------------------------
+  def terminate
+    super
+    dispose_spriteset
+    @info_viewport.dispose
+    RPG::ME.stop
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    super
+    if BattleManager.in_turn?
+      process_event
+      process_action
+    end
+    BattleManager.judge_win_loss
+  end
+  #--------------------------------------------------------------------------
+  # * Update Frame (Basic)
+  #--------------------------------------------------------------------------
+  def update_basic
+    super
+    $game_timer.update
+    $game_troop.update
+    @spriteset.update
+    update_info_viewport
+    update_message_open
+  end
+  #--------------------------------------------------------------------------
+  # * Update Frame (for Wait)
+  #--------------------------------------------------------------------------
+  def update_for_wait
+    update_basic
+  end
+  #--------------------------------------------------------------------------
+  # * Wait
+  #--------------------------------------------------------------------------
+  def wait(duration)
+    duration.times {|i| update_for_wait if i < duration / 2 || !show_fast? }
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Fast Forward
+  #--------------------------------------------------------------------------
+  def show_fast?
+    Input.press?(:A) || Input.press?(:C)
+  end
+  #--------------------------------------------------------------------------
+  # * Wait (No Fast Forward)
+  #--------------------------------------------------------------------------
+  def abs_wait(duration)
+    duration.times {|i| update_for_wait }
+  end
+  #--------------------------------------------------------------------------
+  # * Short Wait (No Fast Forward)
+  #--------------------------------------------------------------------------
+  def abs_wait_short
+    abs_wait(15)
+  end
+  #--------------------------------------------------------------------------
+  # * Wait Until Message Display has Finished
+  #--------------------------------------------------------------------------
+  def wait_for_message
+    @message_window.update
+    update_for_wait while $game_message.visible
+  end
+  #--------------------------------------------------------------------------
+  # * Wait Until Animation Display has Finished
+  #--------------------------------------------------------------------------
+  def wait_for_animation
+    update_for_wait
+    update_for_wait while @spriteset.animation?
+  end
+  #--------------------------------------------------------------------------
+  # * Wait Until Effect Execution Ends
+  #--------------------------------------------------------------------------
+  def wait_for_effect
+    update_for_wait
+    update_for_wait while @spriteset.effect?
+  end
+  #--------------------------------------------------------------------------
+  # * Update Information Display Viewport
+  #--------------------------------------------------------------------------
+  def update_info_viewport
+    move_info_viewport(0)   if @party_command_window.active
+    move_info_viewport(128) if @actor_command_window.active
+    move_info_viewport(64)  if BattleManager.in_turn?
+  end
+  #--------------------------------------------------------------------------
+  # * Move Information Display Viewport
+  #--------------------------------------------------------------------------
+  def move_info_viewport(ox)
+    current_ox = @info_viewport.ox
+    @info_viewport.ox = [ox, current_ox + 16].min if current_ox < ox
+    @info_viewport.ox = [ox, current_ox - 16].max if current_ox > ox
+  end
+  #--------------------------------------------------------------------------
+  # * Update Processing for Opening Message Window
+  #    Set openness to 0 until the status window and so on are finished closing.
+  #--------------------------------------------------------------------------
+  def update_message_open
+    if $game_message.busy? && !@status_window.close?
+      @message_window.openness = 0
+      @status_window.close
+      @party_command_window.close
+      @actor_command_window.close
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Create Sprite Set
+  #--------------------------------------------------------------------------
+  def create_spriteset
+    @spriteset = Spriteset_Battle.new
+  end
+  #--------------------------------------------------------------------------
+  # * Free Sprite Set
+  #--------------------------------------------------------------------------
+  def dispose_spriteset
+    @spriteset.dispose
+  end
+  #--------------------------------------------------------------------------
+  # * Create All Windows
+  #--------------------------------------------------------------------------
+  def create_all_windows
+    create_message_window
+    create_scroll_text_window
+    create_log_window
+    create_status_window
+    create_info_viewport
+    create_party_command_window
+    create_actor_command_window
+    create_help_window
+    create_skill_window
+    create_item_window
+    create_actor_window
+    create_enemy_window
+  end
+  #--------------------------------------------------------------------------
+  # * Create Message Window
+  #--------------------------------------------------------------------------
+  def create_message_window
+    @message_window = Window_Message.new
+  end
+  #--------------------------------------------------------------------------
+  # * Create Scrolling Text Window
+  #--------------------------------------------------------------------------
+  def create_scroll_text_window
+    @scroll_text_window = Window_ScrollText.new
+  end
+  #--------------------------------------------------------------------------
+  # * Create Log Window
+  #--------------------------------------------------------------------------
+  def create_log_window
+    @log_window = Window_BattleLog.new
+    @log_window.method_wait = method(:wait)
+    @log_window.method_wait_for_effect = method(:wait_for_effect)
+  end
+  #--------------------------------------------------------------------------
+  # * Create Status Window
+  #--------------------------------------------------------------------------
+  def create_status_window
+    @status_window = Window_BattleStatus.new
+    @status_window.x = 128
+  end
+  #--------------------------------------------------------------------------
+  # * Create Information Display Viewport
+  #--------------------------------------------------------------------------
+  def create_info_viewport
+    @info_viewport = Viewport.new
+    @info_viewport.rect.y = Graphics.height - @status_window.height
+    @info_viewport.rect.height = @status_window.height
+    @info_viewport.z = 100
+    @info_viewport.ox = 64
+    @status_window.viewport = @info_viewport
+  end
+  #--------------------------------------------------------------------------
+  # * Create Party Commands Window
+  #--------------------------------------------------------------------------
+  def create_party_command_window
+    @party_command_window = Window_PartyCommand.new
+    @party_command_window.viewport = @info_viewport
+    @party_command_window.set_handler(:fight,  method(:command_fight))
+    @party_command_window.set_handler(:escape, method(:command_escape))
+    @party_command_window.unselect
+  end
+  #--------------------------------------------------------------------------
+  # * Create Actor Commands Window
+  #--------------------------------------------------------------------------
+  def create_actor_command_window
+    @actor_command_window = Window_ActorCommand.new
+    @actor_command_window.viewport = @info_viewport
+    @actor_command_window.set_handler(:attack, method(:command_attack))
+    @actor_command_window.set_handler(:skill,  method(:command_skill))
+    @actor_command_window.set_handler(:guard,  method(:command_guard))
+    @actor_command_window.set_handler(:item,   method(:command_item))
+    @actor_command_window.set_handler(:cancel, method(:prior_command))
+    @actor_command_window.x = Graphics.width
+  end
+  #--------------------------------------------------------------------------
+  # * Create Help Window
+  #--------------------------------------------------------------------------
+  def create_help_window
+    @help_window = Window_Help.new
+    @help_window.visible = false
+  end
+  #--------------------------------------------------------------------------
+  # * Create Skill Window
+  #--------------------------------------------------------------------------
+  def create_skill_window
+    @skill_window = Window_BattleSkill.new(@help_window, @info_viewport)
+    @skill_window.set_handler(:ok,     method(:on_skill_ok))
+    @skill_window.set_handler(:cancel, method(:on_skill_cancel))
+  end
+  #--------------------------------------------------------------------------
+  # * Create Item Window
+  #--------------------------------------------------------------------------
+  def create_item_window
+    @item_window = Window_BattleItem.new(@help_window, @info_viewport)
+    @item_window.set_handler(:ok,     method(:on_item_ok))
+    @item_window.set_handler(:cancel, method(:on_item_cancel))
+  end
+  #--------------------------------------------------------------------------
+  # * Create Actor Window
+  #--------------------------------------------------------------------------
+  def create_actor_window
+    @actor_window = Window_BattleActor.new(@info_viewport)
+    @actor_window.set_handler(:ok,     method(:on_actor_ok))
+    @actor_window.set_handler(:cancel, method(:on_actor_cancel))
+  end
+  #--------------------------------------------------------------------------
+  # * Create Enemy Window
+  #--------------------------------------------------------------------------
+  def create_enemy_window
+    @enemy_window = Window_BattleEnemy.new(@info_viewport)
+    @enemy_window.set_handler(:ok,     method(:on_enemy_ok))
+    @enemy_window.set_handler(:cancel, method(:on_enemy_cancel))
+  end
+  #--------------------------------------------------------------------------
+  # * Update Status Window Information
+  #--------------------------------------------------------------------------
+  def refresh_status
+    @status_window.refresh
+  end
+  #--------------------------------------------------------------------------
+  # * To Next Command Input
+  #--------------------------------------------------------------------------
+  def next_command
+    if BattleManager.next_command
+      start_actor_command_selection
+    else
+      turn_start
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * To Previous Command Input
+  #--------------------------------------------------------------------------
+  def prior_command
+    if BattleManager.prior_command
+      start_actor_command_selection
+    else
+      start_party_command_selection
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Start Party Command Selection
+  #--------------------------------------------------------------------------
+  def start_party_command_selection
+    unless scene_changing?
+      refresh_status
+      @status_window.unselect
+      @status_window.open
+      if BattleManager.input_start
+        @actor_command_window.close
+        @party_command_window.setup
+      else
+        @party_command_window.deactivate
+        turn_start
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * [Fight] Command
+  #--------------------------------------------------------------------------
+  def command_fight
+    next_command
+  end
+  #--------------------------------------------------------------------------
+  # * [Escape] Command
+  #--------------------------------------------------------------------------
+  def command_escape
+    turn_start unless BattleManager.process_escape
+  end
+  #--------------------------------------------------------------------------
+  # * Start Actor Command Selection
+  #--------------------------------------------------------------------------
+  def start_actor_command_selection
+    @status_window.select(BattleManager.actor.index)
+    @party_command_window.close
+    @actor_command_window.setup(BattleManager.actor)
+  end
+  #--------------------------------------------------------------------------
+  # * [Attack] Command
+  #--------------------------------------------------------------------------
+  def command_attack
+    BattleManager.actor.input.set_attack
+    select_enemy_selection
+  end
+  #--------------------------------------------------------------------------
+  # * [Skill] Command
+  #--------------------------------------------------------------------------
+  def command_skill
+    @skill_window.actor = BattleManager.actor
+    @skill_window.stype_id = @actor_command_window.current_ext
+    @skill_window.refresh
+    @skill_window.show.activate
+  end
+  #--------------------------------------------------------------------------
+  # * [Guard] Command
+  #--------------------------------------------------------------------------
+  def command_guard
+    BattleManager.actor.input.set_guard
+    next_command
+  end
+  #--------------------------------------------------------------------------
+  # * [Item] Command
+  #--------------------------------------------------------------------------
+  def command_item
+    @item_window.refresh
+    @item_window.show.activate
+  end
+  #--------------------------------------------------------------------------
+  # * Start Actor Selection
+  #--------------------------------------------------------------------------
+  def select_actor_selection
+    @actor_window.refresh
+    @actor_window.show.activate
+  end
+  #--------------------------------------------------------------------------
+  # * Actor [OK]
+  #--------------------------------------------------------------------------
+  def on_actor_ok
+    BattleManager.actor.input.target_index = @actor_window.index
+    @actor_window.hide
+    @skill_window.hide
+    @item_window.hide
+    next_command
+  end
+  #--------------------------------------------------------------------------
+  # * Actor [Cancel]
+  #--------------------------------------------------------------------------
+  def on_actor_cancel
+    @actor_window.hide
+    case @actor_command_window.current_symbol
+    when :skill
+      @skill_window.activate
+    when :item
+      @item_window.activate
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Start Enemy Selection
+  #--------------------------------------------------------------------------
+  def select_enemy_selection
+    @enemy_window.refresh
+    @enemy_window.show.activate
+  end
+  #--------------------------------------------------------------------------
+  # * Enemy [OK]
+  #--------------------------------------------------------------------------
+  def on_enemy_ok
+    BattleManager.actor.input.target_index = @enemy_window.enemy.index
+    @enemy_window.hide
+    @skill_window.hide
+    @item_window.hide
+    next_command
+  end
+  #--------------------------------------------------------------------------
+  # * Enemy [Cancel]
+  #--------------------------------------------------------------------------
+  def on_enemy_cancel
+    @enemy_window.hide
+    case @actor_command_window.current_symbol
+    when :attack
+      @actor_command_window.activate
+    when :skill
+      @skill_window.activate
+    when :item
+      @item_window.activate
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Skill [OK]
+  #--------------------------------------------------------------------------
+  def on_skill_ok
+    @skill = @skill_window.item
+    BattleManager.actor.input.set_skill(@skill.id)
+    BattleManager.actor.last_skill.object = @skill
+    if !@skill.need_selection?
+      @skill_window.hide
+      next_command
+    elsif @skill.for_opponent?
+      select_enemy_selection
+    else
+      select_actor_selection
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Skill [Cancel]
+  #--------------------------------------------------------------------------
+  def on_skill_cancel
+    @skill_window.hide
+    @actor_command_window.activate
+  end
+  #--------------------------------------------------------------------------
+  # * Item [OK]
+  #--------------------------------------------------------------------------
+  def on_item_ok
+    @item = @item_window.item
+    BattleManager.actor.input.set_item(@item.id)
+    if !@item.need_selection?
+      @item_window.hide
+      next_command
+    elsif @item.for_opponent?
+      select_enemy_selection
+    else
+      select_actor_selection
+    end
+    $game_party.last_item.object = @item
+  end
+  #--------------------------------------------------------------------------
+  # * Item [Cancel]
+  #--------------------------------------------------------------------------
+  def on_item_cancel
+    @item_window.hide
+    @actor_command_window.activate
+  end
+  #--------------------------------------------------------------------------
+  # * Battle Start
+  #--------------------------------------------------------------------------
+  def battle_start
+    BattleManager.battle_start
+    process_event
+    start_party_command_selection
+  end
+  #--------------------------------------------------------------------------
+  # * Start Turn
+  #--------------------------------------------------------------------------
+  def turn_start
+    @party_command_window.close
+    @actor_command_window.close
+    @status_window.unselect
+    @subject =  nil
+    BattleManager.turn_start
+    @log_window.wait
+    @log_window.clear
+  end
+  #--------------------------------------------------------------------------
+  # * End Turn
+  #--------------------------------------------------------------------------
+  def turn_end
+    all_battle_members.each do |battler|
+      battler.on_turn_end
+      refresh_status
+      @log_window.display_auto_affected_status(battler)
+      @log_window.wait_and_clear
+    end
+    BattleManager.turn_end
+    process_event
+    start_party_command_selection
+  end
+  #--------------------------------------------------------------------------
+  # * Get All Battle Members Including Enemies and Allies
+  #--------------------------------------------------------------------------
+  def all_battle_members
+    $game_party.members + $game_troop.members
+  end
+  #--------------------------------------------------------------------------
+  # * Event Processing
+  #--------------------------------------------------------------------------
+  def process_event
+    while !scene_changing?
+      $game_troop.interpreter.update
+      $game_troop.setup_battle_event
+      wait_for_message
+      wait_for_effect if $game_troop.all_dead?
+      process_forced_action
+      BattleManager.judge_win_loss
+      break unless $game_troop.interpreter.running?
+      update_for_wait
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Forced Action Processing
+  #--------------------------------------------------------------------------
+  def process_forced_action
+    if BattleManager.action_forced?
+      last_subject = @subject
+      @subject = BattleManager.action_forced_battler
+      BattleManager.clear_action_force
+      process_action
+      @subject = last_subject
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Battle Action Processing
+  #--------------------------------------------------------------------------
+  def process_action
+    return if scene_changing?
+    if !@subject || !@subject.current_action
+      @subject = BattleManager.next_subject
+    end
+    return turn_end unless @subject
+    if @subject.current_action
+      @subject.current_action.prepare
+      if @subject.current_action.valid?
+        @status_window.open
+        execute_action
+      end
+      @subject.remove_current_action
+    end
+    process_action_end unless @subject.current_action
+  end
+  #--------------------------------------------------------------------------
+  # * Processing at End of Action
+  #--------------------------------------------------------------------------
+  def process_action_end
+    @subject.on_action_end
+    refresh_status
+    @log_window.display_auto_affected_status(@subject)
+    @log_window.wait_and_clear
+    @log_window.display_current_state(@subject)
+    @log_window.wait_and_clear
+    BattleManager.judge_win_loss
+  end
+  #--------------------------------------------------------------------------
+  # * Execute Battle Actions
+  #--------------------------------------------------------------------------
+  def execute_action
+    @subject.sprite_effect_type = :whiten
+    use_item
+    @log_window.wait_and_clear
+  end
+  #--------------------------------------------------------------------------
+  # * Use Skill/Item
+  #--------------------------------------------------------------------------
+  def use_item
+    item = @subject.current_action.item
+    @log_window.display_use_item(@subject, item)
+    @subject.use_item(item)
+    refresh_status
+    targets = @subject.current_action.make_targets.compact
+    show_animation(targets, item.animation_id)
+    targets.each {|target| item.repeats.times { invoke_item(target, item) } }
+  end
+  #--------------------------------------------------------------------------
+  # * Invoke Skill/Item
+  #--------------------------------------------------------------------------
+  def invoke_item(target, item)
+    if rand < target.item_cnt(@subject, item)
+      invoke_counter_attack(target, item)
+    elsif rand < target.item_mrf(@subject, item)
+      invoke_magic_reflection(target, item)
+    else
+      apply_item_effects(apply_substitute(target, item), item)
+    end
+    @subject.last_target_index = target.index
+  end
+  #--------------------------------------------------------------------------
+  # * Apply Skill/Item Effect
+  #--------------------------------------------------------------------------
+  def apply_item_effects(target, item)
+    target.item_apply(@subject, item)
+    refresh_status
+    @log_window.display_action_results(target, item)
+  end
+  #--------------------------------------------------------------------------
+  # * Invoke Counterattack
+  #--------------------------------------------------------------------------
+  def invoke_counter_attack(target, item)
+    @log_window.display_counter(target, item)
+    attack_skill = $data_skills[target.attack_skill_id]
+    @subject.item_apply(target, attack_skill)
+    refresh_status
+    @log_window.display_action_results(@subject, attack_skill)
+  end
+  #--------------------------------------------------------------------------
+  # * Invoke Magic Reflection
+  #--------------------------------------------------------------------------
+  def invoke_magic_reflection(target, item)
+    @subject.magic_reflection = true
+    @log_window.display_reflection(target, item)
+    apply_item_effects(@subject, item)
+    @subject.magic_reflection = false
+  end
+  #--------------------------------------------------------------------------
+  # * Apply Substitute
+  #--------------------------------------------------------------------------
+  def apply_substitute(target, item)
+    if check_substitute(target, item)
+      substitute = target.friends_unit.substitute_battler
+      if substitute && target != substitute
+        @log_window.display_substitute(substitute, target)
+        return substitute
+      end
+    end
+    target
+  end
+  #--------------------------------------------------------------------------
+  # * Check Substitute Condition
+  #--------------------------------------------------------------------------
+  def check_substitute(target, item)
+    target.hp < target.mhp / 4 && (!item || !item.certain?)
+  end
+  #--------------------------------------------------------------------------
+  # * Show Animation
+  #     targets      : Target array
+  #     animation_id : Animation ID (-1:  Same as normal attack)
+  #--------------------------------------------------------------------------
+  def show_animation(targets, animation_id)
+    if animation_id < 0
+      show_attack_animation(targets)
+    else
+      show_normal_animation(targets, animation_id)
+    end
+    @log_window.wait
+    wait_for_animation
+  end
+  #--------------------------------------------------------------------------
+  # * Show Attack Animation
+  #     targets : Target array
+  #    Account for dual wield in the case of an actor (flip left hand weapon
+  #    display). If enemy, play the [Enemy Attack] SE and wait briefly.
+  #--------------------------------------------------------------------------
+  def show_attack_animation(targets)
+    if @subject.actor?
+      show_normal_animation(targets, @subject.atk_animation_id1, false)
+      show_normal_animation(targets, @subject.atk_animation_id2, true)
+    else
+      Sound.play_enemy_attack
+      abs_wait_short
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Show Normal Animation
+  #     targets      : Target array
+  #     animation_id : Animation ID
+  #     mirror       : Flip horizontal
+  #--------------------------------------------------------------------------
+  def show_normal_animation(targets, animation_id, mirror = false)
+    animation = $data_animations[animation_id]
+    if animation
+      targets.each do |target|
+        target.animation_id = animation_id
+        target.animation_mirror = mirror
+        abs_wait_short unless animation.to_screen?
+      end
+      abs_wait_short if animation.to_screen?
+    end
+  end
+end