695 lines
26 KiB
Ruby
695 lines
26 KiB
Ruby
|
# -*- coding: utf-8 -*-
|
||
|
|
#==============================================================================
|
||
|
|
# ** 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
|