Foros de Emudesc

class Scene_Battle
#--------------------------------------------------------------------------
# * Open instance variable
#--------------------------------------------------------------------------
attr_reader :status_window # Status Window
attr_reader :spriteset # Battle sprite
attr_reader :scroll_time # Screen portable basic time
attr_reader :zoom_rate # Enemy battler basic position
attr_reader :drive # Camera drive
attr_accessor :force # Degree of action forcing
attr_accessor :camera # Present camera possession person
#--------------------------------------------------------------------------
# * ATB fundamental setup
#--------------------------------------------------------------------------
def atb_setup
# ATB initialization
#
# speed : Battle speed decision. The lower the value, the faster the system
#
# @active : Degree of active setting
# 3 : Always active state
# 2 : ATB pauses when selecting skill/item
# 1 : Same as 2, but pauses during target selection
# 0 : Same as 1, but pauses during command window selection.
#
# @action : Others while acting is the fact that by their causes conduct permitted?
# 3 : If by his is not incapacitation, limited to you permit
# 2 : If by his has not received the damage, you permit
# 1 : In addition to the state of 2, if the target has not acted, you permit
# 0 : Conduct is not permitted. Until it finishes to act in order, it waits
#
# @anime_wait : When it makes true, during battle animation damage indicating wait catches
# @damage_wait : Damage indicatory waiting (as for unit frame)
#
# @after_wait : At the time of ally enemy total loss, until moves to next processing, waiting
# [a, b] a) At the time of party total loss, b) At time of enemy total loss (unit frame)
#
# @enemy_speed : Thought speed of enemy. If 1 immediately conduct.
# In every frame, conduct is caused with the probability of 1/@enemy_speed
#
# @force : With forced action forced condition at time of skill use
# 2: As for skill everything not to reside permanently, by all means immediately execution
# 1: As for independent skill to reside permanently, only cooperation skill immediately execution
# 0: All the skill permanent residence just are done
#
# ($scene.force = Usually by making x, from the script of the event modification possibility)
#
# CAMERA DRIVE SYSTEM: This system moves the Camera POV to the currently moving battler
# @drive : Camera drive system ON/OFF. When true, drive ON, when false drive OFF
# @scroll_time : Time it takes to scroll/move the camera POV during battle
#
# @zoom_rate = [i, j] : Zoom ratio of enemy
# i) When arranging in the picture first section, enlargement ratio
# j) When arranging in the picture lowest section, enlargement ratio
# 1 When liking to make time, 1.0 be sure to set with decimal
speed = 150 # IN FRAMES / FOR ATB SYSTEM
@active = 3 # Active Setting (Range of 0 - 3)
@action = 0 # Action Setting (Range of 0 - 3)
@anime_wait = false #
@damage_wait = 10 #
@after_wait = [80, 0] #
@enemy_speed = 140 #
@force = 2 #
@drive = false # Turns camera system on/off
@scroll_time = 15 # Speed of camera system
@zoom_rate = [0.2, 2.0] # Controls perspective of battlers on screen
@help_time = 40 #
@escape == false #
@camera = nil # Used by system: Determines camera
@max = 0 #
@turn_cnt = 0 # Turns
@help_wait = 0 #
@action_battlers = [] # Used by system to hold battlers
@synthe = [] # Used by system: For Cooperative Skills & such
@spell_p = {} #
@spell_e = {} #
@command_a = false #
@command = [] #
@party = false #
for battler in $game_party.actors + $game_troop.enemies
spell_reset(battler)
battler.at = battler.agi * rand(speed / 2)
battler.damage_pop = {}
battler.damage = {}
battler.damage_sp = {}
battler.critical = {}
battler.recover_hp = {}
battler.recover_sp = {}
battler.state_p = {}
battler.state_m = {}
battler.animation = []
if battler.is_a?(Game_Actor)
@max += battler.agi
end
end
@max *= speed
@max /= $game_party.actors.size

for battler in $game_party.actors + $game_troop.enemies
battler.atp = 100 * battler.at / @max
end
end

#--------------------------------------------------------------------------
# * Full AT Gauge SE
#--------------------------------------------------------------------------
def fullat_se
Audio.se_play("Audio/SE/033-switch02", 80, 100)
end

#--------------------------------------------------------------------------
# * Leveling Up SE
#--------------------------------------------------------------------------
def levelup_se
Audio.se_play("Audio/SE/056-Right02", 80, 100)
end

#--------------------------------------------------------------------------
# * Skill Acquisition SE
#--------------------------------------------------------------------------
def skill_se
Audio.se_play("Audio/SE/056-Right02", 80, 150)
end
end

class Window_Base < Window
#--------------------------------------------------------------------------
# * Draw Actor ATG
# actor : Actor
# x : draw spot x-coordinate
# y : draw spot y-coordinate
# width : draw spot width
#--------------------------------------------------------------------------
def draw_actor_atg(actor, x, y, width = 144)
if @at_gauge == nil
# plus_x: revised x-coordinate
# rate_x: revised X-coordinate as (%)
# plus_y: revised y-coordinate
# plus_width: revised width
# rate_width: revised width as (%)
# height: Vertical width
# align1: Type 1 ( 0: left justify 1: center justify 2: right justify )
# align2: Type 2 ( 0: Upper stuffing 1: Central arranging 2:Lower stuffing )
# align3: Gauge type 0:Left justify 1: Right justify
@plus_x = 0
@rate_x = 0
@plus_y = 16
@plus_width = 0
@rate_width = 100
@width = @plus_width + width * @rate_width / 100
@height = 16
@align1 = 0
@align2 = 1
@align3 = 0
# Gradation settings: grade1: Empty gauge grade2:Actual gauge
# (0:On side gradation 1:Vertically gradation 2: Slantedly gradation)
grade1 = 1
grade2 = 0
# Color setting. color1: Outermost framework, color2: Medium framework
# color3: Empty framework dark color, color4: Empty framework light/write color
color1 = Color.new(0, 0, 0)
color2 = Color.new(255, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 64, 192)
# Color setting of gauge
# Usually color setting of the time
color5 = Color.new(0, 64, 80)
color6 = Color.new(0, 128, 160)
# When gauge is MAX, color setting
color7 = Color.new(80, 0, 0)
color8 = Color.new(240, 0, 0)
# Color setting at time of cooperation skill use
color9 = Color.new(80, 64, 32)
color10 = Color.new(240, 192, 96)
# Color setting at time of skill permanent residence
color11 = Color.new(80, 0, 64)
color12 = Color.new(240, 0, 192)
# Drawing of gauge
gauge_rect_at(@width, @height, @align3, color1, color2,
color3, color4, color5, color6, color7, color8,
color9, color10, color11, color12, grade1, grade2)
end
# Variable at substituting the width of the gauge which is drawn
if actor.rtp == 0
at = (width + @plus_width) * actor.atp * @rate_width / 10000
else
at = (width + @plus_width) * actor.rt * @rate_width / actor.rtp / 100
end
if at > width
at = width
end
# Revision such as the left stuffing central posture of gauge
case @align1
when 1
x += (@rect_width - width) / 2
when 2
x += @rect_width - width
end
case @align2
when 1
y -= @height / 2
when 2
y -= @height
end
self.contents.blt(x + @plus_x + width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(0, 0, @width, @height))
if @align3 == 0
rect_x = 0
else
x += @width - at - 1
rect_x = @width - at - 1
end
# Color setting of gauge
if at == width
# Gauge drawing at the time of MAX
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 2, at, @height))
else
if actor.rtp == 0
# Usually gauge drawing of the time
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height, at, @height))
else
if actor.spell == true
#Gauge drawing at time of cooperation skill use
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 3, at, @height))
else
# Gauge drawing at time of skill permanent residence
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 4, at, @height))
end
end
end
end
end

#================================================= =============================
# ** Scene_Battle (part 1)
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#================================================= =============================

class Scene_Battle
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
# Initialize each kind of temporary battle data
$game_temp.in_battle = true
$game_temp.battle_turn = 0
$game_temp.battle_event_flags.clear
$game_temp.battle_abort = false
$game_temp.battle_main_phase = false
$game_temp.battleback_name = $game_map.battleback_name
$game_temp.forcing_battler = nil
# Initialize battle event interpreter
$game_system.battle_interpreter.setup(nil, 0)
# Prepare troop
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
atb_setup
# Make actor command window
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])
@actor_command_window.y = 160
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
# Make other windows
@party_command_window = Window_PartyCommand.new
@help_window = Window_Help.new
@help_window.back_opacity = 160
@help_window.visible = false
@status_window = Window_BattleStatus.new
@message_window = Window_Message.new
# Make sprite set
@spriteset = Spriteset_Battle.new
# Initialize wait count
@wait_count = 0
# Execute transition
if $data_system.battle_transition == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$data_system.battle_transition)
end
# Start pre-battle phase
start_phase1
# Main loop
loop do
# Update game screen
Graphics.update
# Update input information
Input.update
# Frame update
update
# Abort loop if screen is changed
if $scene != self
break
end
end
# Refresh map
$game_map.refresh
# Prepare for transition
Graphics.freeze
# Dispose of windows
@actor_command_window.dispose
@party_command_window.dispose
@help_window.dispose
@status_window.dispose
@message_window.dispose
if @skill_window != nil
@skill_window.dispose
end
if @item_window != nil
@item_window.dispose
end
if @result_window != nil
@result_window.dispose
end
# Dispose of spriteset
@spriteset.dispose
# If switching to title screen
if $scene.is_a?(Scene_Title)
# Fade out screen
Graphics.transition
Graphics.freeze
end
# If switching from battle test to any screen other than game over screen
if $BTEST and not $scene.is_a?(Scene_Gameover)
$scene = nil
end
end
#--------------------------------------------------------------------------
# * Determine Battle Win/Loss Results
#--------------------------------------------------------------------------
def judge
# If all dead determinant is true, or number of members in party is 0
if $game_party.all_dead? or $game_party.actors.size == 0
# If possible to lose
if $game_temp.battle_can_lose
# Return to BGM before battle starts
$game_system.bgm_play($game_temp.map_bgm)
# Battle end
battle_end(2)
# Return true
return true
end
# Setting the game over flag
$game_temp.gameover = true
# Return true
return true
end
# Return false if even 1 enemy exists
for enemy in $game_troop.enemies
if enemy.exist?
return false
end
end
# Start after battle phase (win)
start_phase5
# Return true
return true
end
#--------------------------------------------------------------------------
# * Frame renewal
#--------------------------------------------------------------------------
def update
# If battle event is running
if $game_system.battle_interpreter.running?
if @command.size > 0
@command_a = false
@command = []
command_delete
end
@status_window.at_refresh
# Update interpreter
$game_system.battle_interpreter.update
# If a battler which is forcing actions doesn't exist
if $game_temp.forcing_battler == nil
# If battle event has finished running
unless $game_system.battle_interpreter.running?
# Refresh status window
@status_window.refresh
setup_battle_event
end
end
end
# Update system (timer) and screen
$game_system.update
$game_screen.update
# If timer has reached 0
if $game_system.timer_working and $game_system.timer == 0
# Abort battle
$game_temp.battle_abort = true
end
# Update windows
@help_window.update
@party_command_window.update
@actor_command_window.update
@status_window.update
@message_window.update
# Update sprite set
@spriteset.update
# If transition is processing
if $game_temp.transition_processing
# Clear transition processing flag
$game_temp.transition_processing = false
# Execute transition
if $game_temp.transition_name == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$game_temp.transition_name)
end
end
# If message window is showing
if $game_temp.message_window_showing
return
end
# If game over
if $game_temp.gameover
# Switch to game over screen
$scene = Scene_Gameover.new
return
end
# If returning to title screen
if $game_temp.to_title
# Switch to title screen
$scene = Scene_Title.new
return
end
# If battle is aborted
if $game_temp.battle_abort
# Return to BGM used before battle started
$game_system.bgm_play($game_temp.map_bgm)
# Battle ends
battle_end(1)
return
end
# If help window is waiting
if @help_wait > 0
@help_wait -= 1
if @help_wait == 0
# Hide help window
@help_window.visible = false
end
end
# When the battler forced into action doesn't exist
# while the battle event is in the midst of executing
if $game_temp.forcing_battler == nil and
$game_system.battle_interpreter.running?
return
end
# Branch according to phase
case @phase
when 0 # AT gauge renewal phase
if anime_wait_return
update_phase0
end
when 1 # pre-battle phase
update_phase1
return
when 2 # party command phase
update_phase2
return
when 5 # after battle phase
update_phase5
return
end
if $scene != self
return
end
if @phase == 0
if @command.size != 0 # Actor command phase
if @command_a == false
start_phase3
end
update_phase3
end
# If waiting
if @wait_count > 0
# Decrease wait count
@wait_count -= 1
return
end
update_phase4
end
end

#================================================= =============================
# ** Scene_Battle (part 2)
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#================================================= =============================

#--------------------------------------------------------------------------
# * Frame renewal (AT gauge renewal phase)
#--------------------------------------------------------------------------
def update_phase0
if $game_temp.battle_turn == 0
$game_temp.battle_turn = 1
end
# If B button was pressed
if @command_a == false and @party == false
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
@party = true
end
end
if @party == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
# Start party command phase
start_phase2
return
end
# AT gauge increase processing
cnt = 0
for battler in $game_party.actors + $game_troop.enemies
active?(battler)
if battler.rtp == 0
if battler.at >= @max
if battler.is_a?(Game_Actor)
if battler.inputable?
unless @action_battlers.include?(battler) or
@command.include?(battler) or @escape == true
if battler.current_action.forcing
fullat_se
force_action(battler)
action_start(battler)
else
fullat_se
@command.push(battler)
end
end
else
unless @action_battlers.include?(battler) or
battler == @command[0]
battler.current_action.clear
if @command.include?(battler)
@command.delete(battler)
else
if battler.movable?
fullat_se
end
end
action_start(battler)
end
end
else
unless @action_battlers.include?(battler)
if battler.current_action.forcing
force_action(battler)
action_start(battler)
else
if @enemy_speed != 0
if rand(@enemy_speed) == 0
number = cnt - $game_party.actors.size
enemy_action(number)
end
else
number = cnt - $game_party.actors.size
enemy_action(number)
end
end
end
end
else
battler.at += battler.agi
if battler.guarding?
battler.at += battler.agi
end
if battler.movable?
battler.atp = 100 * battler.at / @max
end
end
else
if battler.rt >= battler.rtp
speller = synthe?(battler)
if speller != nil
battler = speller[0]
end
unless @action_battlers.include?(battler)
if battler.is_a?(Game_Actor)
fullat_se
end
battler.rt = battler.rtp
action_start(battler)
end
else
battler.rt += battler.agi
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
spell.rt += battler.agi
end
end
end
end
end
cnt += 1
end
# Refresh AT gauge
@status_window.at_refresh
# Escape processing
if @escape == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
temp = false
for battler in $game_party.actors
if battler.inputable?
temp = true
end
end
if temp == true
for battler in $game_party.actors
if battler.at < @max and battler.inputable?
temp = false
break
end
end
if temp == true
@escape = false
for battler in $game_party.actors
battler.at %= @max
end
$game_temp.battle_main_phase = false
update_phase2_escape
end
end
end
end
#--------------------------------------------------------------------------
# * Start Party Command Phase
#--------------------------------------------------------------------------
def start_phase2
# Shift to phase 2
@phase = 2
@party = false
# Enable party command window
@party_command_window.active = true
@party_command_window.visible = true
# Set actor to non-selecting
@actor_index = -1
# Disable actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
if @command.size != 0
# Actor blink effect OFF
if @active_actor != nil
@active_actor.blink = false
end
end
# Camera set
@camera == "party"
@spriteset.screen_target(0, 0, 1)
# Clear main phase flag
$game_temp.battle_main_phase = false
end
#--------------------------------------------------------------------------
# * Frame renewal (party command phase)
#--------------------------------------------------------------------------
def update_phase2
# When C button is pushed
if Input.trigger?(Input::C)
# It diverges at cursor position of the party command window
case @party_command_window.index
when 0 # It fights
# Nullifying the party command window
@party_command_window.active = false
@party_command_window.visible = false
# Performing decision SE
$game_system.se_play($data_system.decision_se)
@escape = false
@phase = 0
if $game_temp.battle_turn == 0
$game_temp.battle_turn = 1
end
if @command_a == true
# Actor command phase start
start_phase3
else
$game_temp.battle_main_phase = true
end
when 1 # It escapes
# When it is not flight possible,
if $game_temp.battle_can_escape == false
# Performing buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Performing decision SE
$game_system.se_play($data_system.decision_se)
@phase = 0
# Nullifying the party command window
@party_command_window.active = false
@party_command_window.visible = false
$game_temp.battle_main_phase = true
if $game_temp.battle_turn == 0
update_phase2_escape
$game_temp.battle_turn = 1
for battler in $game_party.actors
battler.at -= @max / 2
end
return
end
# Performing decision SE
$game_system.se_play($data_system.decision_se)
@escape = true
for battler in $game_party.actors
@command_a = false
@command.delete(battler)
@action_battlers.delete(battler)
skill_reset(battler)
end
end
return
end
end
#--------------------------------------------------------------------------
# * Frame renewal (party command phase: It escapes)
#--------------------------------------------------------------------------
def update_phase2_escape
# The enemy it is fast, calculating mean value
enemies_agi = 0
enemies_number = 0
for enemy in $game_troop.enemies
if enemy.exist?
enemies_agi += enemy.agi
enemies_number += 1
end
end
if enemies_number > 0
enemies_agi /= enemies_number
end
# The actor it is fast, calculating mean value
actors_agi = 0
actors_number = 0
for actor in $game_party.actors
if actor.exist?
actors_agi += actor.agi
actors_number += 1
end
end
if actors_number > 0
actors_agi /= actors_number
end
# Flight success decision
success = rand(100) < 50 * actors_agi / enemies_agi
# In case of flight success
if success
# Performing flight SE
$game_system.se_play($data_system.escape_se)
# You reset to BGM before the battle starting
$game_system.bgm_play($game_temp.map_bgm)
# Battle end
battle_end(1)
# In case of failure of flight
else
@help_window.set_text("Cannot escape", 1)
@help_wait = @help_time
# Clearing the action of party everyone
$game_party.clear_actions
# Main phase start
start_phase4
end
end
#--------------------------------------------------------------------------
# * After battle phase start
#--------------------------------------------------------------------------
def start_phase5
# It moves to phase 5
@phase = 5
# Performing battle end ME
$game_system.me_play($game_system.battle_end_me)
# You reset to BGM before the battle starting
$game_system.bgm_play($game_temp.map_bgm)
# Initializing EXP, the gold and the treasure
exp = 0
gold = 0
treasures = []
if @active_actor != nil
@active_actor.blink = false
end
# Setting the main phase flag
$game_temp.battle_main_phase = true
# Nullifying the party command window
@party_command_window.active = false
@party_command_window.visible = false
# Nullifying the actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
if @skill_window != nil
# Releasing the skill window
@skill_window.dispose
@skill_window = nil
end
if @item_window != nil
# Releasing the item window
@item_window.dispose
@item_window = nil
end
# The help window is hidden
@help_window.visible = false if @help_wait == 0
# Loop
for enemy in $game_troop.enemies
# When the enemy hides and it is not state,
unless enemy.hidden
# Adding acquisition EXP and the gold
exp += enemy.exp
gold += enemy.gold
# Treasure appearance decision
if rand(100) < enemy.treasure_prob
if enemy.item_id > 0
treasures.push($data_items[enemy.item_id])
end
if enemy.weapon_id > 0
treasures.push($data_weapons[enemy.weapon_id])
end
if enemy.armor_id > 0
treasures.push($data_armors[enemy.armor_id])
end
end
end
end
# It limits the number of treasures up to 6
treasures = treasures[0..5]
# EXP acquisition
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
if actor.cant_get_exp? == false
last_level = actor.level
actor.exp += exp
if actor.level > last_level
@status_window.level_up(i)
actor.damage[[actor, -1]] = "Level up!"
actor.up_level = actor.level - last_level
end
end
end
# Gold acquisition
$game_party.gain_gold(gold)
# Treasure acquisition
for item in treasures
case item
when RPG::Item
$game_party.gain_item(item.id, 1)
when RPG::Weapon
$game_party.gain_weapon(item.id, 1)
when RPG::Armor
$game_party.gain_armor(item.id, 1)
end
end
# Drawing up the battle result window
@result_window = Window_BattleResult.new(exp, gold, treasures)
# Setting wait count
@phase5_wait_count = 100
end
#--------------------------------------------------------------------------
# * Frame renewal (after battle phase)
#--------------------------------------------------------------------------
def update_phase5
# When wait count is larger than 0,
if @phase5_wait_count > 0
# Wait count is decreased
@phase5_wait_count -= 1
# When wait count becomes 0,
if @phase5_wait_count == 0
# Indicating the result window
@result_window.visible = true
# Clearing the main phase flag
$game_temp.battle_main_phase = false
# Refreshing the status window
@status_window.refresh
for actor in $game_party.actors
if actor.damage.include?([actor, 0])
@phase5_wait_count = 20
actor.damage_pop[[actor, 0]] = true
end
if actor.damage.include?([actor, -1])
@phase5_wait_count = 20
actor.damage_pop[[actor, -1]] = true
for level in actor.level - actor.up_level + 1..actor.level
for skill in $data_classes[actor.class_id].learnings
if level == skill.level and not actor.skill_learn?(skill.id)
actor.damage[[actor, 0]] = "New Skill!"
break
end
end
end
end
end
end
return
end
# When C button is pushed,
if Input.trigger?(Input::C)
# Battle end
battle_end(0)
end
end

#================================================= =============================
# ** Scene_Battle (Part 3)
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#================================================= =============================

#--------------------------------------------------------------------------
# * Actor command phase start
#--------------------------------------------------------------------------
def start_phase3
if victory?
return
end
# Clearing the main phase flag
$game_temp.battle_main_phase = false
@command_a = true
@active_actor = @command[0]
cnt = 0
for actor in $game_party.actors
if actor == @active_actor
@actor_index = cnt
end
cnt += 1
end
@active_actor.blink = true
unless @active_actor.inputable?
@active_actor.current_action.clear
phase3_next_actor
return
end
phase3_setup_command_window
# Setting of camera
@camera = "command"
plus = ($game_party.actors.size - 1) / 2.0 - @actor_index
y = [(plus.abs - 1.5) * 10 , 0].min
@spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002)
end
#--------------------------------------------------------------------------
# * Command input end of actor
#--------------------------------------------------------------------------
def phase3_next_actor
@command.shift
@command_a = false
# Setting the main phase flag
$game_temp.battle_main_phase = true
# Nullifying the actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
action_start(@active_actor)
# You reset on the basis of the camera
if @camera == "command"
@spriteset.screen_target(0, 0, 1)
end
return
end
#--------------------------------------------------------------------------
# * Setup of actor command window
#--------------------------------------------------------------------------
def phase3_setup_command_window
# Nullifying the party command window
@party_command_window.active = false
@party_command_window.visible = false
# Enabling the actor command window
@actor_command_window.active = true
@actor_command_window.visible = true
# Setting the position of the actor command window
@actor_command_window.x = @actor_index * 160 +
(4 - $game_party.actors.size) * 80
# Setting the index to 0
@actor_command_window.index = 0
end
#--------------------------------------------------------------------------
# * Enemy action compilation
#--------------------------------------------------------------------------
def enemy_action(number)
enemy = $game_troop.enemies[number]
unless enemy.current_action.forcing
enemy.make_action
end
action_start(enemy)
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase)
#--------------------------------------------------------------------------
def update_phase3
if victory? and @command_a
command_delete
@command.push(@active_actor)
return
end
# When the enemy arrow is effective,
if @enemy_arrow != nil
update_phase3_enemy_select
# When the actor arrow is effective,
elsif @actor_arrow != nil
update_phase3_actor_select
# When the skill window is effective,
elsif @skill_window != nil
update_phase3_skill_select
# When the item window is effective
elsif @item_window != nil
update_phase3_item_select
# When the actor command window is effective,
elsif @actor_command_window.active
update_phase3_basic_command
end
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase: Basic command)
#--------------------------------------------------------------------------
def update_phase3_basic_command
unless @active_actor.inputable?
@active_actor.current_action.clear
phase3_next_actor
return
end
# The B when button is pushed,
if Input.trigger?(Input::B) and @party == false
# Performing cancellation SE
$game_system.se_play($data_system.cancel_se)
@party = true
end
if @party == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
# To party command phase
start_phase2
return
end
# When C button is pushed,
if Input.trigger?(Input::C)
@party = false
# It diverges at cursor position of the actor command window
case @actor_command_window.index
when 0 # Attack
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Starting the selection of the enemy
start_enemy_select
when 1 # Skill
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Starting the selection of skill
start_skill_select
when 2 # Defense
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Setting action
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 1
# To command input of the following actor
phase3_next_actor
when 3 # Item
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Starting the selection of the item
start_item_select
end
return
end
# Change Character
if @command.size > 1
# When the R when button is pushed,
if Input.trigger?(Input::R)
$game_system.se_play($data_system.cursor_se)
@party = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
@command.push(@command[0])
@command.shift
@command_a = false
# Start-up of new command window
start_phase3
end
# When the L when button is pushed,
if Input.trigger?(Input::L)
$game_system.se_play($data_system.cursor_se)
@party = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
@command.unshift(@command[@command.size - 1])
@command.delete_at(@command.size - 1)
@command_a = false
# Start-up of new command window
start_phase3
end
# When the right button is pushed,
if Input.trigger?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
@party = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
actor = $game_party.actors[@actor_index]
while actor == @command[0] or (not @command.include?(actor))
@actor_index += 1
@actor_index %= $game_party.actors.size
actor = $game_party.actors[@actor_index]
if actor == @command[0]
break
end
end
while actor != @command[0]
@command.push(@command.shift)
end
@command_a = false
# Start-up of new command window
start_phase3
end
# When the left button is pushed,
if Input.trigger?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
@party = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
actor = $game_party.actors[@actor_index]
while actor == @command[0] or (not @command.include?(actor))
@actor_index -= 1
@actor_index %= $game_party.actors.size
actor = $game_party.actors[@actor_index]
if actor == @command[0]
break
end
end
while actor != @command[0]
@command.push(@command.shift)
end
@command_a = false
# Start-up of new command window
start_phase3
end
end
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase: Skill selection)
#--------------------------------------------------------------------------
def update_phase3_skill_select
# During command selecting when it becomes incapacitation,
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# To command input of the following actor
phase3_next_actor
return
end
# The skill window is put in visible state
@skill_window.visible = true
# Renewing the skill window
@skill_window.update
# The B when button is pushed,
if Input.trigger?(Input::B)
# Performing cancellation SE
$game_system.se_play($data_system.cancel_se)
# End selection of skill
end_skill_select
return
end
# When C button is pushed,
if Input.trigger?(Input::C)
# Acquiring the data which presently is selected in the skill window
@skill = @skill_window.skill
# When you cannot use,
if @skill == nil or not @active_actor.skill_can_use?(@skill.id)
# Performing buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Setting action
@active_actor.current_action.skill_id = @skill.id
# The skill window is put in invisibility state
@skill_window.visible = false
# When the effective range is the enemy single unit,
if @skill.scope == 1
# Starting the selection of the enemy
start_enemy_select
# When the effective range is the friend single unit,
elsif @skill.scope == 3 or @skill.scope == 5
# Starting the selection of the actor
start_actor_select
# When the effective range is not the single unit,
else
# Setting action
@active_actor.current_action.kind = 1
# End selection of skill
end_skill_select
# To command input of the following actor
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase: Item selection)
#--------------------------------------------------------------------------
def update_phase3_item_select
# During command selecting when it becomes incapacitation,
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# To command input of the following actor
phase3_next_actor
return
end
# The item window is put in visible state
@item_window.visible = true
# Renewing the item window
@item_window.update
# The B when button is pushed,
if Input.trigger?(Input::B)
# Performing cancellation SE
$game_system.se_play($data_system.cancel_se)
# End selection of item
end_item_select
return
end
#When C button is pushed,
if Input.trigger?(Input::C)
# Acquiring the data which presently is selected in the item window
@item = @item_window.item
# When you cannot use,
unless $game_party.item_can_use?(@item.id)
# Performing buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Setting action
@active_actor.current_action.item_id = @item.id
# The item window is put in invisibility state
@item_window.visible = false
# When the effective range is the enemy single unit,
if @item.scope == 1
# Starting the selection of the enemy
start_enemy_select
# When the effective range is the friend single unit,
elsif @item.scope == 3 or @item.scope == 5
# Starting the selection of the actor
start_actor_select
# When the effective range is not the single unit,
else
# Setting action
@active_actor.current_action.kind = 2
# End selection of item
end_item_select
# To command input of the following actor
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase: Enemy selection)
#--------------------------------------------------------------------------
def update_phase3_enemy_select
# During command selecting when it becomes incapacitation,
unless @active_actor.inputable?
# You reset on the basis of the camera
if @camera == "select"
@spriteset.screen_target(0, 0, 1)
end
@active_actor.current_action.clear
command_delete
# To command input of the following actor
phase3_next_actor
return
end
# Renewing the enemy arrow
@enemy_arrow.update
# The B when button is pushed,
if Input.trigger?(Input::B)
# Performing cancellation SE
$game_system.se_play($data_system.cancel_se)
# You reset on the basis of the camera
if @camera == "select"
# Setting of camera
@camera = "command"
plus = ($game_party.actors.size - 1) / 2.0 - @actor_index
y = [(plus.abs - 1.5) * 10 , 0].min
@spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002)
end
# End selection of enemy
end_enemy_select
return
end
# When C button is pushed,
if Input.trigger?(Input::C)
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Performing decision SE
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 0
@active_actor.current_action.target_index = @enemy_arrow.index
# When it is in the midst of skill window indicating,
if @skill_window != nil
# Resetting action
@active_actor.current_action.kind = 1
# End selection of skill
end_skill_select
end
# When it is in the midst of item window indicating,
if @item_window != nil
# Resetting action
@active_actor.current_action.kind = 2
# End selection of item
end_item_select
end
# End selection of enemy
end_enemy_select
# To command input of the following actor
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# * Frame renewal (actor command phase: Actor selection)
#--------------------------------------------------------------------------
def update_phase3_actor_select
# During command selecting when it becomes incapacitation,
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# To command input of the following actor
phase3_next_actor
return
end
# Renewing the actor arrow
@actor_arrow.update
# The B when button is pushed,
if Input.trigger?(Input::B)
# Performing cancellation SE
$game_system.se_play($data_system.cancel_se)
# End selection of actor
end_actor_select
return
end
# When C button is pushed,
if Input.trigger?(Input::C)
# Performing decision SE
$game_system.se_play($data_system.decision_se)
# Setting action
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 0
@active_actor.current_action.target_index = @actor_arrow.index
# End selection of actor
end_actor_select
# When it is in the midst of skill window indicating,
if @skill_window != nil
# Resetting action
@active_actor.current_action.kind = 1
# End selection of skill
end_skill_select
end
# When it is in the midst of item window indicating
if @item_window != nil
# Resetting action
@active_actor.current_action.kind = 2
# End selection of item
end_item_select
end
# To command input of the following actor
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# * Start of enemy selection
#--------------------------------------------------------------------------
alias :start_enemy_select_rtab :start_enemy_select
def start_enemy_select
@camera = "select"
for enemy in $game_troop.enemies
if enemy.exist?
zoom = 1 / enemy.zoom
@spriteset.screen_target(enemy.attack_x(zoom) * 0.75,
enemy.attack_y(zoom) * 0.75, zoom)
break
end
end
# Original processing
start_enemy_select_rtab
end
#--------------------------------------------------------------------------
# * Enemy selection end
#--------------------------------------------------------------------------
alias :end_enemy_select_rtab :end_enemy_select
def end_enemy_select
# Original processing
end_enemy_select_rtab
if (@action == 0 and not @action_battlers.empty?) or
(@camera == "select" and (@active_actor.current_action.kind != 0 or
@active_actor.animation1_id != 0))
@spriteset.screen_target(0, 0, 1)
end
end
#--------------------------------------------------------------------------
# * Start of skill selection
#--------------------------------------------------------------------------
def start_skill_select
# Drawing up the skill window
@skill_window = Window_Skill.new(@active_actor)
# Help window association
@skill_window.help_window = @help_window
# Nullifying the actor command window
@actor_command_window.active = false
@actor_command_window.visible = false
end

#================================================= =============================
# ** Scene_Battle (Part 4)
#------------------------------------------------------------------------------
# It is the class which processes the battle picture.
#================================================= =============================

#--------------------------------------------------------------------------
# * Main phase start
#--------------------------------------------------------------------------
def start_phase4
$game_temp.battle_main_phase = true
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase)
#--------------------------------------------------------------------------
def update_phase4
# When the battler who is forced action exists
if $game_temp.forcing_battler != nil
battler = $game_temp.forcing_battler
if battler.current_action.forcing == false
if @action_battlers.include?(battler)
if @action > 0 or @action_battlers[0].phase == 1
@action_battlers.delete(battler)
@action_battlers.push(battler)
end
if battler.phase == 1
battler.current_action.forcing = true
force_action(battler)
end
else
battler.current_action.forcing = true
force_action(battler)
action_start(battler)
@action_battlers.delete(battler)
@action_battlers.push(battler)
end
battler.at = @max
battler.atp = 100 * battler.at / @max
end
end
# When action is 1 or more, conduct is caused simultaneously
for battler in @action_battlers.reverse
# When it is in wait,
if battler.wait > 0
# Wait count is decreased
battler.wait -= 1
break if @action == 0
next
end
unless fin? and battler.phase < 3 and
not $game_system.battle_interpreter.running?
action_phase(battler)
end
break if @action == 0
end
# When the battler who is forced action does not exist
if $game_temp.forcing_battler == nil
# Setting up the battle event
setup_battle_event
# When it is in the midst of battle event executing,
if $game_system.battle_interpreter.running?
return
end
end
# The case where victory or defeat is decided processing
if fin?
# When being defeated, designated time wait
if $game_party.all_dead? and @after_wait[0] > 0
@after_wait[0] -= 1
return
end
# At the time of victory, designated time wait
if victory? and @after_wait[1] > 0
@after_wait[1] -= 1
return
end
# When battle ends, at the same time the actor is immediately before the acting, eliminating the conduct of the actor
for battler in @action_battlers.reverse
if battler.phase < 3 and not $game_system.battle_interpreter.running?
@action_battlers.delete(battler)
end
end
# Victory or defeat decision
if @action_battlers.empty? and
not $game_system.battle_interpreter.running?
judge
end
end
end
#--------------------------------------------------------------------------
# * Action renewal (main phase)
#--------------------------------------------------------------------------
def action_phase(battler)
# When action 1 is, verification whether or not the battler while acting
if @action == 1 and battler.phase <= 3
for target in battler.target
speller = synthe?(target)
if speller == nil
# When the target is in the midst of usual acting,
if @action_battlers.include?(target)
if target.phase > 2
return
end
end
else
# When the target is in the midst of cooperation skill moving
for spell in speller
if @action_battlers.include?(spell)
if spell.phase > 2
return
end
end
end
end
end
end
case battler.phase
when 1
update_phase4_step1(battler)
when 2
update_phase4_step2(battler)
when 3
update_phase4_step3(battler)
when 4
update_phase4_step4(battler)
when 5
update_phase4_step5(battler)
when 6
update_phase4_step6(battler)
end
end
#--------------------------------------------------------------------------
# * Frame Update (main phase step 1 : action preparation)
#--------------------------------------------------------------------------
def update_phase4_step1(battler)
# Already, when it is removed from battle
if battler.index == nil
@action_battlers.delete(battler)
anime_wait_return
return
end
speller = synthe?(battler)
if speller == nil
# When it is while the damage receiving
unless battler.damage.empty? or @action > 2
return
end
# Whether or not conduct possibility decision
unless battler.movable?
battler.phase = 6
return
end
else
# When it is while the damage receiving,
for spell in speller
unless spell.damage.empty? or @action > 2
return
end
# Whether or not conduct possibility decision
unless spell.movable?
battler.phase = 6
return
end
end
end
# At the time of skill use, permanent residence time setting
# When forced action and @force 2 being, skill immediately motion
if battler.current_action.kind == 1 and
(not battler.current_action.forcing or @force != 2)
if battler.rtp == 0
# If it is in the midst of skill residing permanently, cancellation
skill_reset(battler)
# Skill permanent residence time setting
recite_time(battler)
# Cooperation skill setting
synthe_spell(battler)
# When skill you reside permanently,
if battler.rtp > 0
# When forced action and @force 1 being, only cooperation skill immediately motion
speller = synthe?(battler)
if battler.current_action.forcing and @force > 0 and speller != nil
for spell in speller
spell.rt = spell.rtp
end
else
battler.blink = true
if battler.current_action.forcing
$game_temp.forcing_battler = nil
battler.current_action.forcing = false
end
@action_battlers.delete(battler)
return
end
end
end
end
# Blinking effect OFF of actor
if battler != nil
battler.blink = false
end
speller = synthe?(battler)
if speller == nil
@spell_p.delete(battler)
@spell_e.delete(battler)
else
for spell in speller
spell.blink = false
@spell_p.delete(spell)
@spell_e.delete(spell)
end
end
# It moves to step 2
battler.phase = 2
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase step 2: Action start)
#--------------------------------------------------------------------------
def update_phase4_step2(battler)
# If it is not forced action
unless battler.current_action.forcing
# When restriction [ the enemy is attacked ] [ friend attacks ] usually usually
if battler.restriction == 2 or battler.restriction == 3
# Setting attack to action
battler.current_action.kind = 0
battler.current_action.basic = 0
end
end
# It diverges with classification of action
case battler.current_action.kind
when 0 # Basis
if fin?
battler.phase = 6
return
end
make_basic_action_result(battler)
when 1 # Skill
if fin? and $data_skills[battler.current_action.skill_id].scope == 1..2
battler.phase = 6
return
end
make_skill_action_result(battler)
when 2 # Item
if fin? and $data_items[battler.current_action.item_id].scope == 1..2
battler.phase = 6
return
end
make_item_action_result(battler)
end
if battler.phase == 2
# It moves to step 3
battler.phase = 3
end
end
#--------------------------------------------------------------------------
# * Basic action result compilation
#--------------------------------------------------------------------------
def make_basic_action_result(battler)
# In case of attack
if battler.current_action.basic == 0
# Setting animation ID
battler.anime1 = battler.animation1_id
battler.anime2 = battler.animation2_id
# When the conduct side battler is the enemy
if battler.is_a?(Game_Enemy)
if battler.restriction == 3
target = $game_troop.random_target_enemy
elsif battler.restriction == 2
target = $game_party.random_target_actor
else
index = battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
end
end
# When the conduct side battler is the actor
if battler.is_a?(Game_Actor)
if battler.restriction == 3
target = $game_party.random_target_actor
elsif battler.restriction == 2
target = $game_troop.random_target_enemy
else
index = battler.current_action.target_index
target = $game_troop.smooth_target_enemy(index)
end
end
# Setting the arrangement of the object side battler
battler.target = [target]
# Applying the effect of normality attack
for target in battler.target
target.attack_effect(battler)
end
return
end
# In case of defense
if battler.current_action.basic == 1
return
end
# When escapes and is
if battler.is_a?(Game_Enemy) and battler.current_action.basic == 2
return
end
# When what is not and is
if battler.current_action.basic == 3
# It moves to step 6
battler.phase = 6
return
end
end
#--------------------------------------------------------------------------
# * Object side battler setting of skill or item
# scope : Effective range of skill or item
#--------------------------------------------------------------------------
def set_target_battlers(scope, battler)
# When the conduct side battler is the enemy,
if battler.is_a?(Game_Enemy)
# It diverges in the effective range
case scope
when 1 # Enemy single unit
index =battler.current_action.target_index
battler.target.push($game_party.smooth_target_acto r(index))
when 2 # Whole enemy
for actor in $game_party.actors
if actor.exist?
battler.target.push(actor)
end
end
when 3 # Friend single unit
index = battler.current_action.target_index
battler.target.push($game_troop.smooth_target_enem y(index))
when 4 # Whole friend
for enemy in $game_troop.enemies
if enemy.exist?
battler.target.push(enemy)
end
end
when 5 # Friend single unit (HP 0)
index = battler.current_action.target_index
enemy = $game_troop.enemies[index]
if enemy != nil and enemy.hp0?
battler.target.push(enemy)
end
when 6 # Whole friend (HP 0)
for enemy in $game_troop.enemies
if enemy != nil and enemy.hp0?
battler.target.push(enemy)
end
end
when 7 # User
battler.target.push(battler)
end
end
# When the conduct side battler is the actor,
if battler.is_a?(Game_Actor)
# It diverges in the effective range
case scope
when 1 # Enemy single unit
index = battler.current_action.target_index
battler.target.push($game_troop.smooth_target_enem y(index))
when 2 # Whole enemy
for enemy in $game_troop.enemies
if enemy.exist?
battler.target.push(enemy)
end
end
when 3 # Friend single unit
index = battler.current_action.target_index
battler.target.push($game_party.smooth_target_acto r(index))
when 4 # Whole friend
for actor in $game_party.actors
if actor.exist?
battler.target.push(actor)
end
end
when 5 # Friend single unit (HP 0)
index = battler.current_action.target_index
actor = $game_party.actors[index]
if actor != nil and actor.hp0?
battler.target.push(actor)
end
when 6 # Whole friend (HP 0)
for actor in $game_party.actors
if actor != nil and actor.hp0?
battler.target.push(actor)
end
end
when 7 # User
battler.target.push(battler)
end
end
end
#--------------------------------------------------------------------------
# * Skill action result compilation
#--------------------------------------------------------------------------
def make_skill_action_result(battler)
# Acquiring skill
@skill = $data_skills[battler.current_action.skill_id]
# Verification whether or not it is cooperation skill,
speller = synthe?(battler)
# If it is not forced action
unless battler.current_action.forcing
# When with SP and so on is cut off and it becomes not be able to use
if speller == nil
unless battler.skill_can_use?(@skill.id)
# It moves to step 6
battler.phase = 6
return
end
end
end
# SP consumption
temp = false
if speller != nil
for spell in speller
if spell.current_action.spell_id == 0
spell.sp -= @skill.sp_cost
else
spell.sp -= $data_skills[spell.current_action.spell_id].sp_cost
end
# Refreshing the status window
status_refresh(spell)
end
else
battler.sp -= @skill.sp_cost
# Refreshing the status window
status_refresh(battler)
end
# Setting animation ID
battler.anime1 = @skill.animation1_id
battler.anime2 = @skill.animation2_id
# Setting common event ID
battler.event = @skill.common_event_id
# Setting the object side battler
set_target_battlers(@skill.scope, battler)
# Applying the effect of skill
for target in battler.target
if speller != nil
damage = 0
d_result = false
effective = false
state_p = []
state_m = []
for spell in speller
if spell.current_action.spell_id != 0
@skill = $data_skills[spell.current_action.spell_id]
end
effective |= target.skill_effect(spell, @skill)
if target.damage[spell].class != String
d_result = true
damage += target.damage[spell]
elsif effective
effect = target.damage[spell]
end
state_p += target.state_p[spell]
state_m += target.state_m[spell]
target.damage.delete(spell)
target.state_p.delete(spell)
target.state_m.delete(spell)
end
if d_result
target.damage[battler] = damage
elsif effective
target.damage[battler] = effect
else
target.damage[battler] = 0
end
target.state_p[battler] = state_p
target.state_m[battler] = state_m
else
target.skill_effect(battler, @skill)
end
end
end
#--------------------------------------------------------------------------
# * Item action result compilation
#--------------------------------------------------------------------------
def make_item_action_result(battler)
# Acquiring the item
@item = $data_items[battler.current_action.item_id]
# When with the item and so on is cut off and it becomes not be able to use
unless $game_party.item_can_use?(@item.id)
# It moves to step 6
battler.phase = 6
return
end
# In case of consumable
if @item.consumable
# The item which you use is decreased 1
$game_party.lose_item(@item.id, 1)
end
# Setting animation ID
battler.anime1 = @item.animation1_id
battler.anime2 = @item.animation2_id
# Setting common event ID
battler.event = @item.common_event_id
# Deciding the object
index = battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
# Setting the object side battler
set_target_battlers(@item.scope, battler)
# Applying the effect of the item
for target in battler.target
target.item_effect(@item, battler)
end
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase step 3: Conduct side animation)
#--------------------------------------------------------------------------
def update_phase4_step3(battler)
# Renewal of help window. It diverges with classification of action
case battler.current_action.kind
when 0 # Basis
if battler.current_action.basic == 1
@help_window.set_text($data_system.words.guard, 1)
@help_wait = @help_time
end
if battler.current_action.basic == 2
# Escape
@help_window.set_text("Escape", 1)
@help_wait = @help_time
battler.escape
battler.phase = 4
return
end
when 1 # Skill
skill = $data_skills[battler.current_action.skill_id]
@help_window.set_text(skill.name, 1)
@help_wait = @help_time
when 2 # Item
item = $data_items[battler.current_action.item_id]
@help_window.set_text(item.name, 1)
@help_wait = @help_time
end
# When conduct side animation (ID 0 is, the white flash)
if battler.anime1 == 0
battler.white_flash = true
battler.wait = 5
# Camera setting
if battler.target[0].is_a?(Game_Enemy)
camera_set(battler)
end
else
battler.animation.push([battler.anime1, true])
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
if spell.current_action.spell_id == 0
spell.animation.push([battler.anime1, true])
else
skill = spell.current_action.spell_id
spell.animation.push([$data_skills[skill].animation1_id, true])
spell.current_action.spell_id = 0
end
end
end
end
battler.wait = 2 * $data_animations[battler.anime1].frame_max - 10
end
# It moves to step 4
battler.phase = 4
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase step 4: Object side animation)
#--------------------------------------------------------------------------
def update_phase4_step4(battler)
# Camera setting
if battler.target[0].is_a?(Game_Enemy) and battler.anime1 != 0
camera_set(battler)
end
# Object side animation
for target in battler.target
target.animation.push([battler.anime2,
(target.damage[battler] != "Miss")])
unless battler.anime2 == 0
battler.wait = 2 * $data_animations[battler.anime2].frame_max - 10
end
end
# It moves to step 5
battler.phase = 5
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase step 5: Damage indication)
#--------------------------------------------------------------------------
def update_phase4_step5(battler)
# Damage indication
for target in battler.target
if target.damage[battler] != nil
target.damage_pop[battler] = true
target.damage_effect(battler, battler.current_action.kind)
battler.wait = @damage_wait
# Refreshing the status window
status_refresh(target)
end
end
# It moves to step 6
battler.phase = 6
end
#--------------------------------------------------------------------------
# * Frame renewal (main phase step 6: Refreshment)
#--------------------------------------------------------------------------
def update_phase4_step6(battler)
# The camera is reset
if battler.target[0].is_a?(Game_Enemy) and @camera == battler
@spriteset.screen_target(0, 0, 1)
end
# Skill learning
if battler.target[0].is_a?(Game_Actor) and battler.current_action.kind == 1
for target in battler.target
skill_learning(target, target.class_id,
battler.current_action.skill_id)
end
end
# Clearing the battler of the action forced object
if battler.current_action.forcing == true and
battler.current_action.force_kind == 0 and
battler.current_action.force_basic == 0 and
battler.current_action.force_skill_id == 0
$game_temp.forcing_battler = nil
battler.current_action.forcing = false
end
refresh_phase(battler)
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
refresh_phase(spell)
end
end
synthe_delete(speller)
end
# When common event ID is valid
if battler.event > 0
# Setting up the event
common_event = $data_common_events[battler.event]
$game_system.battle_interpreter.setup(common_event .list, 0)
end
act = 0
for actor in $game_party.actors + $game_troop.enemies
if actor.movable?
act += 1
end
end
if @turn_cnt >= act and act > 0
@turn_cnt %= act
$game_temp.battle_turn += 1
# Searching the full page of the battle event
for index in 0...$data_troops[@troop_id].pages.size
# Acquiring the event page
page = $data_troops[@troop_id].pages[index]
# When the span of this page [ turn ] is
if page.span == 1
# Clearing the execution being completed flag
$game_temp.battle_event_flags[index] = false
end
end
end
battler.phase = 1
@action_battlers.delete(battler)
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh_phase(battler)
battler.at -= @max
if battler.movable?
battler.atp = 100 * battler.at / @max
end
spell_reset(battler)
# Slip damage
if battler.hp > 0 and battler.slip_damage?
battler.slip_damage_effect
battler.damage_pop["slip"] = true
end
# State natural cancellation
battler.remove_states_auto
# Refreshing the status window
status_refresh(battler, true)
unless battler.movable?
return
end
# Turn several counts
@turn_cnt += 1
end
#--------------------------------------------------------------------------
# * Battler action start
#--------------------------------------------------------------------------
def action_start(battler)
battler.phase = 1
battler.anime1 = 0
battler.anime2 = 0
battler.target = []
battler.event = 0
@action_battlers.unshift(battler)
end
#--------------------------------------------------------------------------
# * Refreshing the status window
#--------------------------------------------------------------------------
def status_refresh(battler, at = false)
if battler.is_a?(Game_Actor)
for i in 0...$game_party.actors.size
if battler == $game_party.actors[i]
number = i + 1
end
end
@status_window.refresh(number)
if at == true
@status_window.at_refresh(number)
end
end
end
#--------------------------------------------------------------------------
# * Animation wait judgement processing
#--------------------------------------------------------------------------
def anime_wait_return
if (@action_battlers.empty? or @anime_wait == false) and
not $game_system.battle_interpreter.running?
# When the enemy arrow is valid
if @enemy_arrow != nil
return [@active - 2, 0].min == 0
# When the actor arrow is valid
elsif @actor_arrow != nil
return [@active - 2, 0].min == 0
# When the skill window is valid
elsif @skill_window != nil
return [@active - 3, 0].min == 0
# When the item window is valid
elsif @item_window != nil
return [@active - 3, 0].min == 0
# When the actor command window is valid
elsif @actor_command_window.active
return [@active - 1, 0].min == 0
else
return true
end
else
return false
end
end
#--------------------------------------------------------------------------
# * Actor command elimination judgement
#--------------------------------------------------------------------------
def command_delete
# When the enemy arrow is valid
if @enemy_arrow != nil
end_enemy_select
# When the actor is valid
elsif @actor_arrow != nil
end_actor_select
end
# When the skill window is valid
if @skill_window != nil
end_skill_select
# When the item window is valid
elsif @item_window != nil
end_item_select
end
# When the actor command window is valid
if @actor_command_window.active
@command.shift
@command_a = false
# Setting the main phase flag
$game_temp.battle_main_phase = true
# Hides the actor command window when it is invalid
@actor_command_window.active = false
@actor_command_window.visible = false
# Blinking effect OFF of actor
if @active_actor != nil
@active_actor.blink = false
end
end
end
#--------------------------------------------------------------------------
# * Forcing action setting
#--------------------------------------------------------------------------
def force_action(battler)
battler.current_action.kind = battler.current_action.force_kind
battler.current_action.basic = battler.current_action.force_basic
battler.current_action.skill_id = battler.current_action.force_skill_id
battler.current_action.force_kind = 0
battler.current_action.force_basic = 0
battler.current_action.force_skill_id = 0
end
#--------------------------------------------------------------------------
# * Camera set
#--------------------------------------------------------------------------
def camera_set(battler)
@camera = battler
if battler.target.size == 1
if battler.current_action.kind == 0
zoom = 1.2 / battler.target[0].zoom
elsif synthe?(battler) == nil
zoom = 1.5 / battler.target[0].zoom
else
zoom = 2.0 / battler.target[0].zoom
end
@spriteset.screen_target(battler.target[0].attack_x(zoom),
battler.target[0].attack_y(zoom), zoom)
else
@spriteset.screen_target(0, 0, 0.75)
end
end
#--------------------------------------------------------------------------
# * Skill permanent residence time compilation
#--------------------------------------------------------------------------
def recite_time(battler)
end
#--------------------------------------------------------------------------
# * Cooperation skill distinction
#--------------------------------------------------------------------------
def synthe_spell(battler)
end
#--------------------------------------------------------------------------
# * Skill learning system
#--------------------------------------------------------------------------
def skill_learning(actor, class_id, skill_id)
end
#--------------------------------------------------------------------------
# * Conduct possible decision
#--------------------------------------------------------------------------
def active?(battler)
speller = synthe?(battler)
if speller != nil
if synthe_delete?(speller)
return false
end
else
unless battler.inputable?
spell_reset(battler)
unless battler.movable?
battler.atp = 0
return false
end
end
if battler.current_action.forcing
spell_reset(battler)
end
end
return true
end
#--------------------------------------------------------------------------
# * During synthesis skill residing permanently?
#--------------------------------------------------------------------------
def synthe?(battler)
for speller in @synthe
if speller.include?(battler)
return speller
end
end
return nil
end
#--------------------------------------------------------------------------
# * Synthesis skill elimination judgement
#--------------------------------------------------------------------------
def synthe_delete?(speller)
for battler in speller
if not battler.inputable? and dead_ok?(battler)
synthe_delete(speller)
return true
end
end
return false
end
#--------------------------------------------------------------------------
# * Synthesis skill elimination
#--------------------------------------------------------------------------
def synthe_delete(speller)
for battler in speller
spell_reset(battler)
if dead_ok?(battler)
@action_battlers.delete(battler)
end
end
@synthe.delete(speller)
end
#--------------------------------------------------------------------------
# * Cooperation the skill permanent residence cancellation which is included
#--------------------------------------------------------------------------
def skill_reset(battler)
speller = synthe?(battler)
if speller != nil
synthe_delete(speller)
else
spell_reset(battler)
end
end
#--------------------------------------------------------------------------
# * Skill permanent residence cancellation
#--------------------------------------------------------------------------
def spell_reset(battler)
battler.rt = 0
battler.rtp = 0
battler.blink = false
battler.spell = false
battler.current_action.spell_id = 0
@spell_p.delete(battler)
@spell_e.delete(battler)
end
#--------------------------------------------------------------------------
# * Battle end decision
#--------------------------------------------------------------------------
def fin?
return (victory? or $game_party.all_dead? or $game_party.actors.size == 0)
end
#--------------------------------------------------------------------------
# * Enemy total destruction decision
#--------------------------------------------------------------------------
def victory?
for battler in $game_troop.enemies
if not battler.hidden and (battler.rest_hp > 0 or
battler.immortal or battler.damage_pop.size > 0)
return false
end
end
return true
end
#--------------------------------------------------------------------------
# * Death permission decision
#--------------------------------------------------------------------------
def dead_ok?(battler)
speller = synthe?(battler)
if speller == nil
if @action_battlers.include?(battler)
if battler.phase > 2
return false
end
end
else
for battler in speller
if @action_battlers.include?(battler)
if battler.phase > 2
return false
end
end
end
end
return true
end
end

#================================================= =============================
# ** Game_Actor
#------------------------------------------------------------------------------
# It is the class which handles the actor. This class Game_Actors class
# ($game_actors) is used in inside, Game_Party class ($game_party) from is
# referred to.
#================================================= =============================

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Acquisition in battle picture X coordinate
#--------------------------------------------------------------------------
def screen_x
# Calculating X coordinate from line order inside the party, it returns
if self.index != nil
return self.index * 160 + (4 - $game_party.actors.size) * 80 + 80
else
return 0
end
end
end

#================================================= =============================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
# It is the class which collected the sprite of the battle picture. This class
# is used inside Scene_Battle ?? ?.
#================================================= =============================

class Spriteset_Battle
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :real_x # X coordinate revision (presently value)
attr_reader :real_y # Y coordinate revision (presently value)
attr_reader :real_zoom # Enlargement ratio (presently value)
#--------------------------------------------------------------------------
# * Object initialization
#--------------------------------------------------------------------------
def initialize
# Drawing up the viewport
@viewport1 = Viewport.new(0, 0, 640, 480)
@viewport2 = Viewport.new(0, 0, 640, 480)
@viewport3 = Viewport.new(0, 0, 640, 480)
@viewport4 = Viewport.new(0, 0, 640, 480)
@viewport2.z = 101
@viewport3.z = 200
@viewport4.z = 5000
@wait = 0
@real_x = 0
@real_y = 0
@real_zoom = 1.0
@target_x = 0
@target_y = 0
@target_zoom = 1.0
@gap_x = 0
@gap_y = 0
@gap_zoom = 0.0
# Make battleback sprite
@battleback_sprite = Sprite.new(@viewport1)
# Drawing up enemy sprite
@enemy_sprites = []
for enemy in $game_troop.enemies.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
end
# Drawing up actor sprite
@actor_sprites = []
@actor_sprites.push(Sprite_Battler.new(@viewport2) )
@actor_sprites.push(Sprite_Battler.new(@viewport2) )
@actor_sprites.push(Sprite_Battler.new(@viewport2) )
@actor_sprites.push(Sprite_Battler.new(@viewport2) )
# Drawing up the weather
@weather = RPG::Weather.new(@viewport1)
# Drawing up picture sprite
@picture_sprites = []
for i in 51..100
@picture_sprites.push(Sprite_Picture.new(@viewport 3,
$game_screen.pictures[i]))
end
# Drawing up timer sprite
@timer_sprite = Sprite_Timer.new
# Frame renewal
update
end
#--------------------------------------------------------------------------
# * Frame renewal
#--------------------------------------------------------------------------
def update
# Contents of actor sprite renewal (in replacement of actor correspondence)
@actor_sprites[0].battler = $game_party.actors[0]
@actor_sprites[1].battler = $game_party.actors[1]
@actor_sprites[2].battler = $game_party.actors[2]
@actor_sprites[3].battler = $game_party.actors[3]
# When file name of the battle back is different from present ones,
if @battleback_name != $game_temp.battleback_name
make_battleback
end
# Scroll of picture
screen_scroll
# Position revision of monster
for enemy in $game_troop.enemies
enemy.real_x = @real_x
enemy.real_y = @real_y
enemy.real_zoom = @real_zoom
end
# Renewing battler sprite
for sprite in @enemy_sprites + @actor_sprites
sprite.update
end
# Renewing weather graphics
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.update
# Renewing picture sprite
for sprite in @picture_sprites
sprite.update
end
# Renewing timer sprite
@timer_sprite.update
# Setting the color tone and shake position of the picture
@viewport1.tone = $game_screen.tone
@viewport1.ox = $game_screen.shake
# Setting the flash color of the picture
@viewport4.color = $game_screen.flash_color
# Renewing the viewport
@viewport1.update
@viewport2.update
@viewport4.update
end
#--------------------------------------------------------------------------
# * Setting of battle background
#--------------------------------------------------------------------------
def make_battleback
@battleback_name = $game_temp.battleback_name
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
@battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name)
if @battleback_sprite.bitmap.width == 640 and
@battleback_sprite.bitmap.height == 320
@battleback_sprite.src_rect.set(0, 0, 1280, 640)
@base_zoom = 2.0
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@real_y = 4
@battleback_sprite.x = 320
@battleback_sprite.y = @real_y
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
elsif @battleback_sprite.bitmap.width == 640 and
@battleback_sprite.bitmap.height == 480
@battleback_sprite.src_rect.set(0, 0, 960, 720)
@base_zoom = 1.5
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@battleback_sprite.x = 320
@battleback_sprite.y = 0
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
else
@battleback_sprite.src_rect.set(0, 0, @battleback_sprite.bitmap.width,
@battleback_sprite.bitmap.height)
@base_zoom = 1.0
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@battleback_sprite.x = 320
@battleback_sprite.y = 0
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
end
end
#--------------------------------------------------------------------------
# * Position enlargement ratio setting of scroll goal of picture
#--------------------------------------------------------------------------
def screen_target(x, y, zoom)
return unless $scene.drive
@wait = $scene.scroll_time
@target_x = x
@target_y = y
@target_zoom = zoom
screen_over
@gap_x = @target_x - @real_x
@gap_y = @target_y - @real_y
@gap_zoom = @target_zoom - @real_zoom
end
#--------------------------------------------------------------------------
# * Scroll of picture
#--------------------------------------------------------------------------
def screen_scroll
if @wait > 0
@real_x = @target_x - @gap_x * (@wait ** 2) / ($scene.scroll_time ** 2)
@real_y = @target_y - @gap_y * (@wait ** 2) / ($scene.scroll_time ** 2)
@real_zoom = @target_zoom -
@gap_zoom * (@wait ** 2) / ($scene.scroll_time ** 2)
@battleback_sprite.x = 320 + @real_x
@battleback_sprite.y = @real_y
@battleback_sprite.zoom_x = @base_zoom * @real_zoom
@battleback_sprite.zoom_y = @base_zoom * @real_zoom
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
@wait -= 1
end
end
#--------------------------------------------------------------------------
# * When the screen goes outside the picture, revision processing
#--------------------------------------------------------------------------
def screen_over
width = @battleback_sprite.bitmap.width * @base_zoom * @target_zoom / 2
unless 324 + @target_x > width and 324 - @target_x > width
if 324 + @target_x > width
@target_x = width - 324
elsif 324 - @target_x > width
@target_x = 324 - width
end
end
height = @battleback_sprite.bitmap.height * @base_zoom * @target_zoom / 4
unless @target_y > height - 4 and 484 - @target_y > 3 * height
if @target_y > height - 4
@target_y = height - 4
elsif 484 - @target_y > 3 * height
@target_y = 484 - 3 * height
end
end
end
end

#================================================= =============================
# ** Game_Battler (Part 1)
#------------------------------------------------------------------------------
# It is the class which handles the battler. This class is used as superclass
# of Game_Actor class and Game_Enemy ?? ?.
#================================================= =============================

class Game_Battler
#--------------------------------------------------------------------------
# * Release instance variable addition
#--------------------------------------------------------------------------
attr_accessor :up_level # The frequency of levelling up
attr_accessor :at # AT (time gauge)
attr_accessor :atp # AT (for indication)
attr_accessor :rt # RP (permanent residence gauge)
attr_accessor :rtp # RP (permanent residence necessary quantity)
attr_accessor :spell # In the midst of synthesis skill motion
attr_accessor :recover_hp # HP recovery quantity
attr_accessor :recover_sp # SP recovery quantity
attr_accessor :state_p # Status abnormal arrangement
attr_accessor :state_m # Status abnormal arrangement
attr_accessor :damage_sp # SP damage indicatory flag
attr_accessor :animation # Arrangement of animation ID and Hit
attr_accessor hase
attr_accessor :wait
attr_accessor :target
attr_accessor :anime1
attr_accessor :anime2
attr_accessor :event
#--------------------------------------------------------------------------
# * Object initialization
#--------------------------------------------------------------------------
alias :initialize_rtab :initialize
def initialize
initialize_rtab
@damage_pop = {}
@da