Need help with battle script.

Tethius · August 7, 2011

I am using RTAB ver 1.16 for RMXP and I was wondering if there was some sort of edit i could perform to change the battle window from one individual border around each character, to a single battle window. When there is only 1 person in my party, the battle window only surrounds the picture of the battle sprite, leaving black on both sides of it. I would like 1 solid battle window, despite the number of characters in battle.

Here are some screen describing my problem, and what i want it to look like.

the problem

what i want

Also, I would like the battler itself to stay centered, but i want the whole window.

This is the script.

# Real time active battle (RTAB) Ver 1.16

# Distribution original support URL

# http://members.jcom.home.ne.jp/cogwheel/

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 system speed. Lower values speeds up the system.

#

# @active : Degree of active setting (Command Window control)

# 3 : Always active state

# 2 : System 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 : Degree of action setting (Battler Action control)

# 3 : Actions are performed unless incapacitated/dead

# 2 : Actions are delayed when taking damage

# 1 : Actions are delayed during the opponent/target's turn

# 0 : Actions are delayed until his/her turn

#

# @anime_wait : If true, the system pauses until Battle Animation is done.

#

# @damage_wait : Sets how long (in frames) a delay will last after the

# damage pop shows.

#

# @after_wait : The delay (in frames) after the battle is finished before

# moving to the 'game over' screen or showing the 'battle

# result' window.

# [a, b] a) delay for party loss, b) delay for enemy loss.

#

# @enemy_speed : Reaction delay speed of enemy (in frames). The Enemy

# reacts immediately if this is set to 1 (do not use '0').

# Action is caused with the chance 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 SYSTEM : This system moves the Camera POV to the current battler.

# @drive : Camera drive system ON/OFF. If true, the system is ON.

# @scroll_time : Time it takes to scroll/move the camera POV during battle.

# @zoom_rate : This controls the size/depth of the enemy battlers in the

# window. If both set to 1.0, no scaling performed.

# [i, j] i) Highest/furthest enemy, j) Lowest/closest enemy

# -Decimal values are permitted.-

# -System zooms in/out to target (scaled to 1) on decisions.

#--Configurables--#

speed = 300 # IN FRAMES / FOR ATB SYSTEM

@active = 3 # Active Setting (Range of 0 - 3) -Command Window-

@action = 1 # Action Setting (Range of 0 - 3) -Battler Action-

@anime_wait = true # Pause system for battle animation

@damage_wait = 60 # Delay after damage pop appears, in frames

@after_wait = [80, 80] # Delay for party/troop after battle loss

@enemy_speed = 160 # Speed delay setting for enemy action

@force = 2 #

@drive = false # Turns camera system on/off

@scroll_time = 15 # Speed of camera system

@zoom_rate = [1.0, 1.0] # Controls perspective of battlers on screen

#--Reserved for the system, do not touch--#

@help_time = 40 # Reserved: Length of window delay, in frames

@escape == false # Reserved: Determines if escape is possible

@camera = nil # Reserved: Determines camera

@max = 0 # Reserved: To calculate max game speed

@turn_cnt = 0 # Reserved: Counts turns

@help_wait = 0 # Reserved: Help window delay

@action_battlers = [] # Reserved: Holds battlers

@synthe = [] # Reserved: For Cooperative Skills & such

@spell_p = {} # Reserved: Spell caster/battler array

@spell_e = {} # Reserved: Spell caster/battler array

@command_a = false # Reserved: Determine if actor battler in use

@command = [] # Reserved: Available commands

@party = false # Reserved: Party Command Window flag

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

@max *= speed

@max /= $game_party.actors.size

for battler in $game_party.actors + $game_troop.enemies

battler.atp = 100 * battler.at / @max

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

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

#==============================================================================

# ** 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

# 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

#--------------------------------------------------------------------------

# * 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

# 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

# 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

# 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

# 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

#==============================================================================

# ** 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

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

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

action_start(battler)

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

else

battler.at += battler.agi

if battler.guarding?

battler.at += battler.agi

end

if battler.movable?

battler.atp = 100 * battler.at / @max

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

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

if temp == true

for battler in $game_party.actors

if battler.at < @max and battler.inputable?

temp = false

break

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

#--------------------------------------------------------------------------

# * 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

# 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

return

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

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

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

#--------------------------------------------------------------------------

# * 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

# 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

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

# 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

# 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

return

end

# When C button is pushed,

if Input.trigger?(Input::C)

# Battle end

battle_end(0)

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

#--------------------------------------------------------------------------

# * 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

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

while actor != @command[0]

@command.push(@command.shift)

end

@command_a = false

# Start-up of new command window

start_phase3

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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

# 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

#--------------------------------------------------------------------------

# * 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

# 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

# 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

# Victory or defeat decision

if @action_battlers.empty? and

not $game_system.battle_interpreter.running?

judge

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

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

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

#--------------------------------------------------------------------------

# * 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

# 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

# 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

# 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

# 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

#--------------------------------------------------------------------------

# * 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

# 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

# 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

#--------------------------------------------------------------------------

# * 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_actor(index))

when 2 # Whole enemy

for actor in $game_party.actors

if actor.exist?

battler.target.push(actor)

end

when 3 # Friend single unit

index = battler.current_action.target_index

battler.target.push($game_troop.smooth_target_enemy(index))

when 4 # Whole friend

for enemy in $game_troop.enemies

if enemy.exist?

battler.target.push(enemy)

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

when 7 # User

battler.target.push(battler)

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_enemy(index))

when 2 # Whole enemy

for enemy in $game_troop.enemies

if enemy.exist?

battler.target.push(enemy)

end

when 3 # Friend single unit

index = battler.current_action.target_index

battler.target.push($game_party.smooth_target_actor(index))

when 4 # Whole friend

for actor in $game_party.actors

if actor.exist?

battler.target.push(actor)

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

when 7 # User

battler.target.push(battler)

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

# 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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

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

# 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

# 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

# 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

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

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

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

number = i + 1

end

@status_window.refresh(number)

if at == true

@status_window.at_refresh(number)

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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

if battler.current_action.forcing

spell_reset(battler)

end

return true

end

#--------------------------------------------------------------------------

# * During synthesis skill residing permanently?

#--------------------------------------------------------------------------

def synthe?(battler)

for speller in @synthe

if speller.include?(battler)

return speller

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

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

@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

#--------------------------------------------------------------------------

# * 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

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

else

for battler in speller

if @action_battlers.include?(battler)

if battler.phase > 2

return false

end

return true

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

#==============================================================================

# ** 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))

# 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(@viewport3,

$game_screen.pictures))

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

#--------------------------------------------------------------------------

# * 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

#--------------------------------------------------------------------------

# * 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

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

#==============================================================================

# ** 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 :phase

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 = {}

@damage = {}

@damage_sp = {}

@critical = {}

@recover_hp = {}

@recover_sp = {}

@state_p = {}

@state_m = {}

@animation = []

@phase = 1

@wait = 0

@target = []

@anime1 = 0

@anime2 = 0

@event = 0

end

#--------------------------------------------------------------------------

# * Existence decision

#--------------------------------------------------------------------------

def exist?

return (not @hidden and (@hp > 0 or @immortal or @damage.size > 0))

end

#--------------------------------------------------------------------------

# * Remaining HP estimate

#--------------------------------------------------------------------------

def rest_hp

# Substituting reality HP to rest_hp

rest_hp = @hp

# All damage which the battler receives is made to reflect on rest_hp

for pre_damage in @damage

if pre_damage[1].is_a?(Numeric)

rest_hp -= pre_damage[1]

end

return rest_hp

end

#--------------------------------------------------------------------------

# * Cancellation of state

# state_id : State ID

# force : Forced cancellation flag (with processing of automatic state use)

#--------------------------------------------------------------------------

def remove_state(state_id, force = false)

# When this state is added,

if state?(state_id)

# When with the state which it is forced is added, at the same time cancellation is not forcing

if @states_turn[state_id] == -1 and not force

# Method end

return

end

# When present HP 0 and option [ the state of HP 0 you regard ] it is valid

if @hp == 0 and $data_states[state_id].zero_hp

# Whether or not [ you regard the state of HP 0 ] there is a state in other things, decision

zero_hp = false

for i in @states

if i != state_id and $data_states.zero_hp

zero_hp = true

end

# If you are possible to cancel aggressive failure, HP in 1 modification

if zero_hp == false

@hp = 1

end

unless self.movable?

# Deleting state ID from @states arrangement and @states_turn hash

@states.delete(state_id)

@states_turn.delete(state_id)

if self.movable?

self.at = 0

end

else

# Deleting state ID from @states arrangement and @states_turn hash

@states.delete(state_id)

@states_turn.delete(state_id)

end

# The maximum check of HP and SP

@hp = [@hp, self.maxhp].min

@sp = [@sp, self.maxsp].min

end

#--------------------------------------------------------------------------

# * Effective application of normality attack

# attacker : Attack person (battler)

#--------------------------------------------------------------------------

def attack_effect(attacker)

# Clearing the critical flag

self.critical[attacker] = false

state_p[attacker] = []

state_m[attacker] = []

# First on-target hit decision

hit_result = (rand(100) < attacker.hit)

# In case of on-target hit

hit_result = true

if hit_result == true

# Calculating the basic damage

atk = [attacker.atk - self.pdef / 2, 0].max

self.damage[attacker] = atk * (20 + attacker.str) / 20

# Attribute correction

self.damage[attacker] *= elements_correct(attacker.element_set)

self.damage[attacker] /= 100

# When the mark of the damage is correct,

if self.damage[attacker] > 0

# Critical correction

if rand(100) < 4 * attacker.dex / self.agi

self.damage[attacker] *= 2

self.critical[attacker] = true

end

# Defense correction

if self.guarding?

self.damage[attacker] /= 2

end

# Dispersion

if self.damage[attacker].abs > 0

amp = [self.damage[attacker].abs * 15 / 100, 1].max

self.damage[attacker] += rand(amp+1) + rand(amp+1) - amp

end

# Second on-target hit decision

eva = 8 * self.agi / attacker.dex + self.eva

hit = self.damage[attacker] < 0 ? 100 : 100 - eva

hit = self.cant_evade? ? 100 : hit

hit_result = (rand(100) < hit)

end

# In case of on-target hit

if hit_result == true

# State shocking cancellation

remove_states_shock

# From HP damage subtraction

# State change

@state_changed = false

states_plus(attacker, attacker.plus_state_set)

states_minus(attacker, attacker.minus_state_set)

# In case of miss

else

# Setting "Miss" to the damage

self.damage[attacker] = "Miss"

# Clearing the critical flag

self.critical[attacker] = false

end

# Method end

return true

end

#--------------------------------------------------------------------------

# * Effective application of skill

# user : User of skill (battler)

# skill : Skill

#--------------------------------------------------------------------------

def skill_effect(user, skill)

# Clearing the critical flag

self.critical[user] = false

state_p[user] = []

state_m[user] = []

# Effective range of skill with friend of HP 1 or more, your own HP 0,

# Or when the effective range of skill with the friend of HP 0, your own HP are 1 or more

if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or

((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)

# Method end

return false

end

# Clearing the effective flag

effective = false

# When common event ID is valid setting the effective flag

effective |= skill.common_event_id > 0

# First on-target hit decision

hit = skill.hit

if skill.atk_f > 0

hit *= user.hit / 100

end

hit_result = (rand(100) < hit)

# In case of uncertain skill setting the effective flag

effective |= hit < 100

# In case of on-target hit

if hit_result == true

# Calculating power

power = skill.power + user.atk * skill.atk_f / 100

if power > 0

power -= self.pdef * skill.pdef_f / 200

power -= self.mdef * skill.mdef_f / 200

power = [power, 0].max

end

# Calculating magnification ratio

rate = 20

rate += (user.str * skill.str_f / 100)

rate += (user.dex * skill.dex_f / 100)

rate += (user.agi * skill.agi_f / 100)

rate += (user.int * skill.int_f / 100)

# Calculating the basic damage

self.damage[user] = power * rate / 20

# Attribute correction

self.damage[user] *= elements_correct(skill.element_set)

self.damage[user] /= 100

# When the mark of the damage is correct

if self.damage[user] > 0

# Defense correction

if self.guarding?

self.damage[user] /= 2

end

# Dispersion

if skill.variance > 0 and self.damage[user].abs > 0

amp = [self.damage[user].abs * skill.variance / 100, 1].max

self.damage[user] += rand(amp+1) + rand(amp+1) - amp

end

# Second on-target hit decision

eva = 8 * self.agi / user.dex + self.eva

hit = self.damage[user] < 0 ? 100 : 100 - eva * skill.eva_f / 100

hit = self.cant_evade? ? 100 : hit

hit_result = (rand(100) < hit)

# In case of uncertain skill setting the effective flag

effective |= hit < 100

end

# In case of on-target hit

if hit_result == true

# In case of physical attack other than power 0

if skill.power != 0 and skill.atk_f > 0

# State shocking cancellation

remove_states_shock

# Setting the effective flag

effective = true

end

# The fluctuation decision of HP

last_hp = [[self.hp - self.damage[user], self.maxhp].min, 0].max # Effective decision

effective |= self.hp != last_hp

# State change

@state_changed = false

effective |= states_plus(user, skill.plus_state_set)

effective |= states_minus(user, skill.minus_state_set)

unless $game_temp.in_battle

self.damage_effect(user, 1)

end

# When power 0 is,

if skill.power == 0

# Setting the null line to the damage

self.damage[user] = ""

# When there is no change in the state,

unless @state_changed

# Setting "Miss" to the damage

self.damage[user] = "Miss"

end

# In case of miss

else

# Setting "Miss" to the damage

self.damage[user] = "Miss"

end

# When it is not in the midst of fighting,

unless $game_temp.in_battle

# Setting nil to the damage

self.damage[user] = nil

end

# Method end

return effective

end

#--------------------------------------------------------------------------

# * Effective application of item

# item : Item

#--------------------------------------------------------------------------

def item_effect(item, user = $game_party.actors[0])

# Clearing the critical flag

self.critical[user] = false

state_p[user] = []

state_m[user] = []

self.recover_hp[user] = 0

self.recover_sp[user] = 0

# Effective range of item with friend of HP 1 or more, your own HP 0,

# Or when the effective range of the item with the friend of HP 0, your own HP are 1 or more,

if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or

((item.scope == 5 or item.scope == 6) and self.hp >= 1)

# Method end

return false

end

# Clearing the effective flag

effective = false

# When common event ID is valid setting the effective flag

effective |= item.common_event_id > 0

# On-target hit decision

hit_result = (rand(100) < item.hit)

# In case of uncertain skill setting the effective flag

effective |= item.hit < 100

# In case of on-target hit

if hit_result == true

# Calculating the recovery quantity

self.recover_hp[user] = maxhp * item.recover_hp_rate / 100 +

item.recover_hp

self.recover_sp[user] = maxsp * item.recover_sp_rate / 100 +

item.recover_sp

if self.recover_hp[user] < 0

self.recover_hp[user] += self.pdef * item.pdef_f / 20

self.recover_hp[user] += self.mdef * item.mdef_f / 20

self.recover_hp[user] = [self.recover_hp[user], 0].min

end

# Attribute correction

self.recover_hp[user] *= elements_correct(item.element_set)

self.recover_hp[user] /= 100

self.recover_sp[user] *= elements_correct(item.element_set)

self.recover_sp[user] /= 100

# Dispersion

if item.variance > 0 and self.recover_hp[user].abs > 0

amp = [self.recover_hp[user].abs * item.variance / 100, 1].max

self.recover_hp[user] += rand(amp+1) + rand(amp+1) - amp

end

if item.variance > 0 and self.recover_sp[user].abs > 0

amp = [self.recover_sp[user].abs * item.variance / 100, 1].max

self.recover_sp[user] += rand(amp+1) + rand(amp+1) - amp

end

# When the mark of the recovery quantity is negative number

if self.recover_hp[user] < 0

# Defense correction

if self.guarding?

self.recover_hp[user] /= 2

end

# The mark of the HP recovery quantity it reverses, sets to the value of the damage

self.damage[user] = -self.recover_hp[user]

# The fluctuation decision of HP and SP

last_hp = [[self.hp + self.recover_hp[user], self.maxhp].min, 0].max

last_sp = [[self.sp + self.recover_sp[user], self.maxsp].min, 0].max

effective |= self.hp != last_hp

effective |= self.sp != last_sp

# State change

@state_changed = false

effective |= states_plus(user, item.plus_state_set)

effective |= states_minus(user, item.minus_state_set)

unless $game_temp.in_battle

self.damage_effect(user, 2)

end

# When parameter rise value is valid

if item.parameter_type > 0 and item.parameter_points != 0

# It diverges with parameter

case item.parameter_type

when 1 # MaxHP

@maxhp_plus += item.parameter_points

when 2 # MaxSP

@maxsp_plus += item.parameter_points

when 3 #Strength

@str_plus += item.parameter_points

when 4 # Dexterity

@dex_plus += item.parameter_points

when 5 # Agility

@agi_plus += item.parameter_points

when 6 # Intelligence

@int_plus += item.parameter_points

end

# Setting the effective flag

effective = true

end

# When HP recovery factor and the recovery quantity 0 is

if item.recover_hp_rate == 0 and item.recover_hp == 0

# Setting the null line to the damage

self.damage[user] = ""

# When SP recovery factor and the recovery quantity 0, parameter rise value is invalid,

if item.recover_sp_rate == 0 and item.recover_sp == 0 and

(item.parameter_type == 0 or item.parameter_points == 0)

# When there is no change in the state,

unless @state_changed

# Setting "Miss" to the damage

self.damage[user] = "Miss"

end

# In case of miss

else

# Setting "Miss" to the damage

self.damage[user] = "Miss"

end

# When it is not in the midst of fighting,

unless $game_temp.in_battle

# Setting nil to the damage

self.damage[user] = nil

end

# Method end

return effective

end

#--------------------------------------------------------------------------

# * State change (+) application

# plus_state_set : State change (+)

#--------------------------------------------------------------------------

def states_plus(battler, plus_state_set)

# Clearing the effective flag

effective = false

# The loop (the state which is added)

for i in plus_state_set

# When this state is not defended,

unless self.state_guard?(i)

# If this state is not full, setting the effective flag

effective |= self.state_full?(i) == false

# When the state [ it does not resist ] is,

if $data_states.nonresistance

# Setting the state change flag

@state_changed = true

# Adding the state

self.state_p[battler].push(i)

# When this state is not full,

elsif self.state_full?(i) == false

# It converts degree of state validity to probability, compares with random number

if rand(100) < [0,100,80,60,40,20,0][self.state_ranks]

# Setting the state change flag

@state_changed = true

# Adding the state

self.state_p[battler].push(i)

end

# Method end

return effective

end

#--------------------------------------------------------------------------

# * State change (-) application

# minus_state_set : State change (-)

#--------------------------------------------------------------------------

def states_minus(battler, minus_state_set)

# Clearing the effective flag

effective = false

# The loop (the state which is cancelled)

for i in minus_state_set

# If this state is added, setting the effective flag

effective |= self.state?(i)

# Setting the state change flag

@state_changed = true

# Cancelling the state

self.state_m[battler].push(i)

end

# Method end

return effective

end

#--------------------------------------------------------------------------

# * Damage operation

#--------------------------------------------------------------------------

def damage_effect(battler, item)

if item == 2

self.hp += self.recover_hp[battler]

self.sp += self.recover_sp[battler]

if self.recover_sp[battler] != 0

self.damage_sp[battler] = -self.recover_sp[battler]

end

self.recover_hp.delete(battler)

self.recover_sp.delete(battler)

else

if self.damage[battler].class != String

self.hp -= self.damage[battler]

end

for i in self.state_p[battler]

add_state(i)

end

for i in self.state_m[battler]

remove_state(i)

end

#--------------------------------------------------------------------------

# * Effective application of slip damage

#--------------------------------------------------------------------------

def slip_damage_effect

# Setting the damage

self.damage["slip"] = self.maxhp / 10

# Dispersion

if self.damage["slip"].abs > 0

amp = [self.damage["slip"].abs * 15 / 100, 1].max

self.damage["slip"] += rand(amp+1) + rand(amp+1) - amp

end

# From HP damage subtraction

self.hp -= self.damage["slip"]

# Method end

return true

end

#==============================================================================

# ** Game_BattleAction

#------------------------------------------------------------------------------

# 　Action (the conduct which is in the midst of fighting) it is the class which

# is handled. This class is used inside Game_Battler クラス.

#==============================================================================

class Game_BattleAction

#--------------------------------------------------------------------------

# * Public Instance Variables

#--------------------------------------------------------------------------

attr_accessor :spell_id # Skill ID for union magic

attr_accessor :force_kind # Classification (basis/skill/item)

attr_accessor :force_basic # basis (attack/defend/escape)

attr_accessor :force_skill_id # Skill ID

#--------------------------------------------------------------------------

# * Validity decision

#--------------------------------------------------------------------------

def valid?

return (not (@force_kind == 0 and @force_basic == 3))

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

def skill_can_use?(skill_id)

return super

end

#==============================================================================

# ** Game_Enemy

#------------------------------------------------------------------------------

# 　It is the class which handles the enemy. This class Game_Troop class

# ($game_troop) is used in inside.

#==============================================================================

class Game_Enemy < Game_Battler

#--------------------------------------------------------------------------

# * Public Instance Variables

#--------------------------------------------------------------------------

attr_accessor :height # Height of picture

attr_accessor :real_x # X-coordinate revision

attr_accessor :real_y # Y-coordinate revision

attr_accessor :real_zoom # Enlargement ratio

#--------------------------------------------------------------------------

# * Object initialization

# troop_id :Troop ID

# member_index : Index of troop member

#--------------------------------------------------------------------------

def initialize(troop_id, member_index)

super()

@troop_id = troop_id

@member_index = member_index

troop = $data_troops[@troop_id]

@enemy_id = troop.members[@member_index].enemy_id

enemy = $data_enemies[@enemy_id]

@battler_name = enemy.battler_name

@battler_hue = enemy.battler_hue

@hp = maxhp

@sp = maxsp

@real_x = 0

@real_y = 0

@real_zoom = 1.0

@fly = 0

enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {@fly = $1.to_i}

@hidden = troop.members[@member_index].hidden

@immortal = troop.members[@member_index].immortal

end

alias :true_x :screen_x

alias :true_y :screen_y

#--------------------------------------------------------------------------

# * Acquisition in battle picture X coordinate

#--------------------------------------------------------------------------

def screen_x

return 320 + (true_x - 320) * @real_zoom + @real_x

end

#--------------------------------------------------------------------------

# * Acquisition in battle picture Y coordinate

#--------------------------------------------------------------------------

def screen_y

return true_y * @real_zoom + @real_y

end

#--------------------------------------------------------------------------

# * Acquisition in battle picture Z coordinate

#--------------------------------------------------------------------------

def screen_z

return true_y + @fly

end

#--------------------------------------------------------------------------

# * Acquisition of battle picture enlargement ratio

#--------------------------------------------------------------------------

def zoom

return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) *

(true_y + @fly) / 320 + $scene.zoom_rate[0]

end

#--------------------------------------------------------------------------

# * For attack and acquisition in battle picture X coordinate

#--------------------------------------------------------------------------

def attack_x(z)

return (320 - true_x) * z * 0.75

end

#--------------------------------------------------------------------------

# * For attack and acquisition of battle picture Y-coordinate

#--------------------------------------------------------------------------

def attack_y(z)

return (160 - (true_y + @fly / 4) * z + @height * zoom * z / 2) * 0.75

end

#--------------------------------------------------------------------------

# * Action compilation

#--------------------------------------------------------------------------

def make_action

# Clearing current action

self.current_action.clear

# When it cannot move,

unless self.inputable?

# Method end

return

end

# Presently extracting effective action

available_actions = []

rating_max = 0

for action in self.actions

# Turn conditional verification

n = $game_temp.battle_turn

a = action.condition_turn_a

b = action.condition_turn_b

if (b == 0 and n != a) or

(b > 0 and (n < 1 or n < a or n % b != a % b))

next

end

# HP conditional verification

if self.hp * 100.0 / self.maxhp > action.condition_hp

next

end

# Level conditional verification

if $game_party.max_level < action.condition_level

next

end

# Switch conditional verification

switch_id = action.condition_switch_id

if switch_id > 0 and $game_switches[switch_id] == false

next

end

# Skill active conditional verification

if action.kind == 1

unless self.skill_can_use?(action.skill_id)

next

end

# It corresponds to condition : Adding this action

available_actions.push(action)

if action.rating > rating_max

rating_max = action.rating

end

# Maximum rating value as 3 total calculation (as for 0 or less exclusion)

ratings_total = 0

for action in available_actions

if action.rating > rating_max - 3

ratings_total += action.rating - (rating_max - 3)

end

# When total of rating 0 is not,

if ratings_total > 0

# Drawing up random number

value = rand(ratings_total)

# Setting those which correspond to the random number which it drew up to current action

for action in available_actions

if action.rating > rating_max - 3

if value < action.rating - (rating_max - 3)

self.current_action.kind = action.kind

self.current_action.basic = action.basic

self.current_action.skill_id = action.skill_id

self.current_action.decide_random_target_for_enemy

return

else

value -= action.rating - (rating_max - 3)

end

#==============================================================================

# ** Game_Party

#------------------------------------------------------------------------------

# 　It is the class which handles the party. Information of the gold and the

# item etc. is included. Instance of this ク lath is referred to being

# $game_party.

#==============================================================================

class Game_Party

#--------------------------------------------------------------------------

# * Total destruction decision

#--------------------------------------------------------------------------

def all_dead?

# When party number of people 0 is

if $game_party.actors.size == 0

return false

end

# When the actor of HP 0 or more is in the party,

for actor in @actors

if actor.rest_hp > 0

return false

end

# Total destruction

return true

end

#--------------------------------------------------------------------------

# * Random of object actor decision

# hp0 : Limits to the actor of HP 0

#--------------------------------------------------------------------------

# Original target decisive routine smooth_target_actor_rtab and name modification

alias :random_target_actor_rtab :random_target_actor

def random_target_actor(hp0 = false)

# Initializing the roulette

roulette = []

# Loop

for actor in @actors

# When it corresponds to condition

if (not hp0 and actor.exist? and actor.rest_hp > 0) or

(hp0 and actor.hp0?)

# Acquiring the [ position ] of class of actor

position = $data_classes[actor.class_id].position

# At the time of avant-garde n = 4、At the time of medium defense n = 3、At the time rear guard n = 2

n = 4 - position

# In roulette actor n time addition

n.times do

roulette.push(actor)

end

# When size of the roulette 0 is

if roulette.size == 0

return random_target_actor_rtab(hp0)

end

# It turns the roulette, deciding the actor

return roulette[rand(roulette.size)]

end

#--------------------------------------------------------------------------

# * Smooth decision of object actor

# actor_index : actor index

#--------------------------------------------------------------------------

# Original target decisive routine smooth_target_actor_rtab and name modification

alias :smooth_target_actor_rtab :smooth_target_actor

def smooth_target_actor(actor_index)

# Acquiring the actor

actor = @actors[actor_index]

# When the actor exists

if actor != nil and actor.exist? and actor.rest_hp > 0

return actor

end

# Loop

for actor in @actors

# When the actor exists

if actor.exist? and actor.rest_hp > 0

return actor

end

# When friend has destroyed, original target decisive routine is executed

return smooth_target_actor_rtab(actor_index)

end

#==============================================================================

# ** Game_Troop

#------------------------------------------------------------------------------

# 　It is the class which handles the troop. As for instance of this class with

# $game_troop reference the れ it increases.

#==============================================================================

class Game_Troop

#--------------------------------------------------------------------------

# * Random of object enemy decision

# hp0 : It limits to the enemy of HP 0

#--------------------------------------------------------------------------

# Original target decisive routine random_target_enemy_rtab and name modification

alias :random_target_enemy_rtab :random_target_enemy

def random_target_enemy(hp0 = false)

# Initializing the roulette

roulette = []

# Loop

for enemy in @enemies

# When it corresponds to condition,

if (not hp0 and enemy.exist? and enemy.rest_hp > 0) or

(hp0 and enemy.hp0?)

# Adding the enemy to the roulette

roulette.push(enemy)

end

# When size of the roulette 0 is,

if roulette.size == 0

return random_target_enemy_rtab(hp0)

end

# It turns the roulette, deciding the enemy

return roulette[rand(roulette.size)]

end

#--------------------------------------------------------------------------

# * Smooth decision of object enemy

# enemy_index : enemy index

#--------------------------------------------------------------------------

# Original target decisive routine smooth_target_enemy_rtab and name modification

alias :smooth_target_enemy_rtab :smooth_target_enemy

def smooth_target_enemy(enemy_index)

# Acquiring the enemy

enemy = @enemies[enemy_index]

# When the enemy exists,

if enemy != nil and enemy.exist? and enemy.rest_hp > 0

return enemy

end

# Loop

for enemy in @enemies

# When the enemy exists,

if enemy.exist? and enemy.rest_hp > 0

return enemy

end

# When the enemy has destroyed, it searches the enemy for the second time

return smooth_target_enemy_rtab(enemy_index)

end

#==============================================================================

# ** Sprite_Battler

#------------------------------------------------------------------------------

# 　It is sprite for battler indication. Instance of Game_Battler class is watched,

# state of sprite changes automatically.

#==============================================================================

class Sprite_Battler < RPG::Sprite

#--------------------------------------------------------------------------

# * Frame Renewal

#--------------------------------------------------------------------------

def update

super

# When the battler is nil

if @battler == nil

self.bitmap = nil

loop_animation(nil)

return

end

# When file name or hue differs from present ones

if @battler.battler_name != @battler_name or

@battler.battler_hue != @battler_hue

# To acquire bitmap, setting

@battler_name = @battler.battler_name

@battler_hue = @battler.battler_hue

self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)

@width = bitmap.width

@height = bitmap.height

self.ox = @width / 2

self.oy = @height

if @battler.is_a?(Game_Enemy)

@battler.height = @height

end

# Aggressive failure or it hides and if state it designates opacity as 0

if @battler.dead? or @battler.hidden

self.opacity = 0

end

# When animation ID differs from present ones

if @battler.state_animation_id != @state_animation_id

@state_animation_id = @battler.state_animation_id

loop_animation($data_animations[@state_animation_id])

end

# In case of the actor whom it should indicate

if @battler.is_a?(Game_Actor) and @battler_visible

# When being main phase, opacity is lowered a little

if $game_temp.battle_main_phase

self.opacity += 3 if self.opacity < 255

else

self.opacity -= 3 if self.opacity > 207

end

# Blinking

if @battler.blink

blink_on

else

blink_off

end

# In case of invisibility

unless @battler_visible

# Appearance

if not @battler.hidden and not @battler.dead? and

(@battler.damage.size < 2 or @battler.damage_pop.size < 2)

appear

@battler_visible = true

end

# Damage

for battler in @battler.damage_pop

if battler[0].class == Array

if battler[0][1] >= 0

$scene.skill_se

else

$scene.levelup_se

end

damage(@battler.damage[battler[0]], false, 2)

else

damage(@battler.damage[battler[0]], @battler.critical[battler[0]])

end

if @battler.damage_sp.include?(battler[0])

damage(@battler.damage_sp[battler[0]],

@battler.critical[battler[0]], 1)

@battler.damage_sp.delete(battler[0])

end

@battler.damage_pop.delete(battler[0])

@battler.damage.delete(battler[0])

@battler.critical.delete(battler[0])

end

# When it is visible

if @battler_visible

# Flight

if @battler.hidden

$game_system.se_play($data_system.escape_se)

escape

@battler_visible = false

end

# White Flash

if @battler.white_flash

whiten

@battler.white_flash = false

end

# Animation

unless @battler.animation.empty?

for animation in @battler.animation.reverse

animation($data_animations[animation[0]], animation[1])

@battler.animation.delete(animation)

end

# Collapse

if @battler.damage.empty? and @battler.dead?

if $scene.dead_ok?(@battler)

if @battler.is_a?(Game_Enemy)

$game_system.se_play($data_system.enemy_collapse_se)

else

$game_system.se_play($data_system.actor_collapse_se)

end

collapse

@battler_visible = false

end

# Setting the coordinate of sprite

self.x = @battler.screen_x

self.y = @battler.screen_y

self.z = @battler.screen_z

if @battler.is_a?(Game_Enemy)

self.zoom_x = @battler.real_zoom * @battler.zoom

self.zoom_y = @battler.real_zoom * @battler.zoom

end

#==============================================================================

# ** Window_Base

#------------------------------------------------------------------------------

# 　It is superclass of all windows in the game.

#==============================================================================

class Window_Base < Window

#--------------------------------------------------------------------------

# * Drawing of gauge

#--------------------------------------------------------------------------

def gauge_rect_at(width, height, align3,

color1, color2, color3, color4, color5, color6, color7,

color8, color9, color10, color11, color12, grade1, grade2)

# Framework drawing

@at_gauge = Bitmap.new(width, height * 5)

@at_gauge.fill_rect(0, 0, width, height, color1)

@at_gauge.fill_rect(1, 1, width - 2, height - 2, color2)

if (align3 == 1 and grade1 == 0) or grade1 > 0

color = color3

color3 = color4

color4 = color

end

if (align3 == 1 and grade2 == 0) or grade2 > 0

color = color5

color5 = color6

color6 = color

color = color7

color7 = color8

color8 = color

color = color9

color9 = color10

color10 = color

color = color11

color11 = color12

color12 = color

end

if align3 == 0

if grade1 == 2

grade1 = 3

end

if grade2 == 2

grade2 = 3

end

# Drawing vertically of empty gauge gradation indication

@at_gauge.gradation_rect(2, 2, width - 4, height - 4,

color3, color4, grade1)

# Drawing of actual gauge

@at_gauge.gradation_rect(2, height + 2, width- 4, height - 4,

color5, color6, grade2)

@at_gauge.gradation_rect(2, height * 2 + 2, width- 4, height - 4,

color7, color8, grade2)

@at_gauge.gradation_rect(2, height * 3 + 2, width- 4, height - 4,

color9, color10, grade2)

@at_gauge.gradation_rect(2, height * 4 + 2, width- 4, height - 4,

color11, color12, grade2)

end

#==============================================================================

# ** Window_Help

#------------------------------------------------------------------------------

# 　It is the window which indicates the item description the skill and the

# status etc. of the actor.

#==============================================================================

class Window_Help < Window_Base

#--------------------------------------------------------------------------

# * Enemy Setting

# enemy : The enemy which indicates name and the state

#--------------------------------------------------------------------------

def set_enemy(enemy)

text = enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {""}

state_text = make_battler_state_text(enemy, 112, false)

if state_text != ""

text += " " + state_text

end

set_text(text, 1)

end

#==============================================================================

# ** Window_BattleStatus

#------------------------------------------------------------------------------

# 　It is the window which indicates the status of the party member in the

# battle picture.

#==============================================================================

class Window_BattleStatus < Window_Base

#--------------------------------------------------------------------------

# * Object Initialization

#--------------------------------------------------------------------------

def initialize

x = (4 - $game_party.actors.size) * 80

width = $game_party.actors.size * 160

super(x, 320, width, 160)

self.back_opacity = 160

@actor_window = []

for i in 0...$game_party.actors.size

@actor_window.push(Window_ActorStatus.new(i, x + i * 160))

end

@level_up_flags = [false, false, false, false]

refresh

end

#--------------------------------------------------------------------------

# * Dispose

#--------------------------------------------------------------------------

def dispose

for window in @actor_window

window.dispose

end

super

end

#--------------------------------------------------------------------------

# * Refresh

#--------------------------------------------------------------------------

def refresh(number = 0) if number == 0

cnt = 0

for window in @actor_window

window.refresh(@level_up_flags[cnt])

cnt += 1

end

else

@actor_window[number - 1].refresh(@level_up_flags[number - 1])

end

#--------------------------------------------------------------------------

# * AT gauge refreshment

#--------------------------------------------------------------------------

def at_refresh(number = 0)

if number == 0

for window in @actor_window

window.at_refresh

end

else

@actor_window[number - 1].at_refresh

end

#--------------------------------------------------------------------------

# * Frame Renewal

#--------------------------------------------------------------------------

def update

super

if self.x != (4 - $game_party.actors.size) * 80

self.x = (4 - $game_party.actors.size) * 80

self.width = $game_party.actors.size * 160

for window in @actor_window

window.dispose

end

@actor_window = []

for i in 0...$game_party.actors.size

@actor_window.push(Window_ActorStatus.new(i, x + i * 160))

end

refresh

end

for window in @actor_window

window.update

end

#==============================================================================

# ** Window_ActorStatus

#------------------------------------------------------------------------------

# 　It is the window which indicates the status of the party member respectively

# in the battle picture.

#==============================================================================

class Window_ActorStatus < Window_Base

#--------------------------------------------------------------------------

# * Object Initialization

#--------------------------------------------------------------------------

def initialize(id, x)

@actor_num = id

super(x, 320, 160, 160)

self.contents = Bitmap.new(width - 32, height - 32)

self.opacity = 0

self.back_opacity = 0

actor = $game_party.actors[@actor_num]

@actor_nm = actor.name

@actor_mhp = actor.maxhp

@actor_msp = actor.maxsp

@actor_hp = actor.hp

@actor_sp = actor.sp

@actor_st = make_battler_state_text(actor, 120, true)

@status_window = []

for i in 0...5

@status_window.push(Window_DetailsStatus.new(actor, i, x))

end

refresh(false)

end

#--------------------------------------------------------------------------

# * Dispose

#--------------------------------------------------------------------------

def dispose

for i in 0...5

@status_window.dispose

end

super

end

#--------------------------------------------------------------------------

# * Refresh

#--------------------------------------------------------------------------

def refresh(level_up_flags)

self.contents.clear

actor = $game_party.actors[@actor_num]

@status_window[0].refresh(actor) if @actor_nm != actor.name

@status_window[1].refresh(actor) if

@actor_mhp != actor.maxhp or @actor_hp != actor.hp

@status_window[2].refresh(actor) if

@actor_msp != actor.maxsp or @actor_sp != actor.sp

@status_window[3].refresh(actor, level_up_flags) if

@actor_st != make_battler_state_text(actor, 120, true) or level_up_flags

@actor_nm = actor.name

@actor_mhp = actor.maxhp

@actor_msp = actor.maxsp

@actor_hp = actor.hp

@actor_sp = actor.sp

@actor_st = make_battler_state_text(actor, 120, true)

end

#--------------------------------------------------------------------------

# * AT gauge refreshment

#--------------------------------------------------------------------------

def at_refresh

@status_window[4].refresh($game_party.actors[@actor_num])

end

#--------------------------------------------------------------------------

# * Frame Renewal

#--------------------------------------------------------------------------

def update

for window in @status_window

window.update

end

#==============================================================================

# ** Window_DetailsStatus

#------------------------------------------------------------------------------

# 　It is the window which indicates the status of the actor in individually in the battle picture.

#==============================================================================

class Window_DetailsStatus < Window_Base

#--------------------------------------------------------------------------

# * Object Initialization

#--------------------------------------------------------------------------

def initialize(actor, id, x)

@status_id = id

super(x, 320 + id * 26, 160, 64)

self.contents = Bitmap.new(width - 32, height - 32)

self.opacity = 0

self.back_opacity = 0

refresh(actor, false)

end

#--------------------------------------------------------------------------

# * Dispose

#--------------------------------------------------------------------------

def dispose

super

end

#--------------------------------------------------------------------------

# * Refresh

#--------------------------------------------------------------------------

def refresh(actor, level_up_flags = false)

self.contents.clear

case @status_id

when 0

draw_actor_name(actor, 4, 0)

when 1

draw_actor_hp(actor, 4, 0, 120)

when 2

draw_actor_sp(actor, 4, 0, 120)

when 3

if level_up_flags

self.contents.font.color = normal_color

self.contents.draw_text(4, 0, 120, 32, "LEVEL UP!")

else

draw_actor_state(actor, 4, 0)

end

when 4

draw_actor_atg(actor, 4, 0, 120)

end

#--------------------------------------------------------------------------

# * Frame renewal

#--------------------------------------------------------------------------

def update

#At the time of main phase opacity is lowered a little

if $game_temp.battle_main_phase

self.contents_opacity -= 4 if self.contents_opacity > 191

else

self.contents_opacity += 4 if self.contents_opacity < 255

end

#==============================================================================

# ** Arrow_Base

#------------------------------------------------------------------------------

# 　It is sprite for the arrow cursor indication which is used in the battle picture.

# This class is used as superclass of Arrow_Enemy class and Arrow_Actor class.

#==============================================================================

class Arrow_Base < Sprite

#--------------------------------------------------------------------------

# * Object Initialization

# viewport :viewport

#--------------------------------------------------------------------------

def initialize(viewport)

super(viewport)

self.bitmap = RPG::Cache.windowskin($game_system.windowskin_name)

self.ox = 16

self.oy = 32

self.z = 2500

@blink_count = 0

@index = 0

@help_window = nil

update

end

#==============================================================================

# ** Arrow_Enemy

#------------------------------------------------------------------------------

# 　It is arrow cursor in order to make the enemy select.

# This class succeeds Arrow_Base.

#==============================================================================

class Arrow_Enemy < Arrow_Base

#--------------------------------------------------------------------------

# * Frame renewal

#--------------------------------------------------------------------------

def update

super

# When it points to the enemy which does not exist, it throws

$game_troop.enemies.size.times do

break if self.enemy.exist?

@index += 1

@index %= $game_troop.enemies.size

end

# The cursor right

if Input.repeat?(Input::RIGHT)

$game_system.se_play($data_system.cursor_se)

$game_troop.enemies.size.times do

@index += 1

@index %= $game_troop.enemies.size

break if self.enemy.exist?

end

$scene.camera = "select"

zoom = 1 / self.enemy.zoom

$scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75,

self.enemy.attack_y(zoom) * 0.75, zoom)

end

# The cursor left

if Input.repeat?(Input::LEFT)

$game_system.se_play($data_system.cursor_se)

$game_troop.enemies.size.times do

@index += $game_troop.enemies.size - 1

@index %= $game_troop.enemies.size

break if self.enemy.exist?

end

$scene.camera = "select"

zoom = 1 / self.enemy.zoom

$scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75,

self.enemy.attack_y(zoom) * 0.75, zoom)

end

# Setting the coordinate of sprite

if self.enemy != nil

self.x = self.enemy.screen_x

self.y = self.enemy.screen_y

end

#==============================================================================

# ** Interpreter

#------------------------------------------------------------------------------

# It is the interpreter which executes event command. This class is used inside

# the Game_System class and Game_Event class.

#==============================================================================

class Interpreter

#--------------------------------------------------------------------------

# * Change Party Member

#--------------------------------------------------------------------------

def command_129

# Acquiring the actor

actor = $game_actors[@parameters[0]]

# When the actor is valid

if actor != nil

# It diverges with operation

if @parameters[1] == 0

if @parameters[2] == 1

$game_actors[@parameters[0]].setup(@parameters[0])

end

$game_party.add_actor(@parameters[0])

if $game_temp.in_battle

$game_actors[@parameters[0]].at = 0

$game_actors[@parameters[0]].atp = 0

$scene.spell_reset($game_actors[@parameters[0]])

$game_actors[@parameters[0]].damage_pop = {}

$game_actors[@parameters[0]].damage = {}

$game_actors[@parameters[0]].damage_sp = {}

$game_actors[@parameters[0]].critical = {}

$game_actors[@parameters[0]].recover_hp = {}

$game_actors[@parameters[0]].recover_sp = {}

$game_actors[@parameters[0]].state_p = {}

$game_actors[@parameters[0]].state_m = {}

$game_actors[@parameters[0]].animation = []

end

else

$game_party.remove_actor(@parameters[0])

end

if $game_temp.in_battle

$scene.status_window.update

end

# Continuation

return true

end

#--------------------------------------------------------------------------

# * The increase and decrease of HP

#--------------------------------------------------------------------------

alias :command_311_rtab :command_311

def command_311

command_311_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# *The increase and decrease of SP

#--------------------------------------------------------------------------

alias :command_312_rtab :command_312

def command_312

command_312_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Modification of state

#--------------------------------------------------------------------------

alias :command_313_rtab :command_313

def command_313

command_313_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * All recovery

#--------------------------------------------------------------------------

alias :command_314_rtab :command_314

def command_314

command_314_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * The increase and decrease of EXP

#--------------------------------------------------------------------------

alias :command_315_rtab :command_315

def command_315

command_315_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Increase and decrease of level

#--------------------------------------------------------------------------

alias :command_316_rtab :command_316

def command_316

command_316_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Increase and decrease of parameter

#--------------------------------------------------------------------------

alias :command_317_rtab :command_317

def command_317

command_317_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Modification of equipment

#--------------------------------------------------------------------------

alias :command_319_rtab :command_319

def command_319

command_319_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Name modification of actor

#--------------------------------------------------------------------------

alias :command_320_rtab :command_320

def command_320

command_320_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Class modification of actor

#--------------------------------------------------------------------------

alias :command_321_rtab :command_321

def command_321

command_321_rtab

if $game_temp.in_battle

$scene.status_window.refresh

end

#--------------------------------------------------------------------------

# * Indication of animation

#--------------------------------------------------------------------------

def command_337

# Process iteration

iterate_battler(@parameters[0], @parameters[1]) do |battler|

# When the battler exists

if battler.exist?

# Setting animation ID

battler.animation.push([@parameters[2], true])

end

# continuous

return true

end

#--------------------------------------------------------------------------

# * Deal Damage

#--------------------------------------------------------------------------

def command_338

# of the damage the value which is operated acquisition

value = operate_value(0, @parameters[2], @parameters[3])

# Process iteration

iterate_battler(@parameters[0], @parameters[1]) do |battler|

# battler exists with

if battler.exist?

# HP modification

battler.hp -= value

# fighting

if $game_temp.in_battle

# damage setting

battler.damage["event"] = value

battler.damage_pop["event"] = true

end

if $game_temp.in_battle

$scene.status_window.refresh

end

# continuation

return true

end

#--------------------------------------------------------------------------

# * Forcing the action

#--------------------------------------------------------------------------

def command_339

# If it is not in the midst of fighting, disregard

unless $game_temp.in_battle

return true

end

# If the number of turns 0 disregard

if $game_temp.battle_turn == 0

return true

end

# Processing (With convenient ones, there are no times when it becomes plural)

iterate_battler(@parameters[0], @parameters[1]) do |battler|

# When the battler exists,

if battler.exist?

# Setting action

battler.current_action.force_kind = @parameters[2]

if battler.current_action.force_kind == 0

battler.current_action.force_basic = @parameters[3]

else

battler.current_action.force_skill_id = @parameters[3]

end

# Setting the conduct object

if @parameters[4] == -2

if battler.is_a?(Game_Enemy)

battler.current_action.decide_last_target_for_enemy

else

battler.current_action.decide_last_target_for_actor

end

elsif @parameters[4] == -1

if battler.is_a?(Game_Enemy)

battler.current_action.decide_random_target_for_enemy

else

battler.current_action.decide_random_target_for_actor

end

elsif @parameters[4] >= 0

battler.current_action.target_index = @parameters[4]

end

# When action validity and [ directly execution ] is,

if battler.current_action.valid? and @parameters[5] == 1

# Setting the battler of the forced object

$game_temp.forcing_battler = battler

# The index is advanced

@index += 1

# end

return false

elsif battler.current_action.valid? and @parameters[5] == 0

battler.current_action.forcing = true

end

# continuation

return true

end

#==============================================================================

# * Sprite module

#------------------------------------------------------------------------------

# This module manages and controls animation.

#==============================================================================

module RPG

class Sprite < ::Sprite

def initialize(viewport = nil)

super(viewport)

@_whiten_duration = 0

@_appear_duration = 0

@_escape_duration = 0

@_collapse_duration = 0

@_damage = []

@_animation = []

@_animation_duration = 0

@_blink = false

end

def damage(value, critical, type = 0)

if value.is_a?(Numeric)

damage_string = value.abs.to_s

else

damage_string = value.to_s

end

bitmap = Bitmap.new(160, 48)

bitmap.font.name = "Arial Black"

bitmap.font.size = 32

bitmap.font.color.set(0, 0, 0)

bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)

bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)

bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)

bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)

if value.is_a?(Numeric) and value < 0

if type == 0

bitmap.font.color.set(176, 255, 144)

else

bitmap.font.color.set(176, 144, 255)

end

else

if type == 0

bitmap.font.color.set(255, 255, 255)

else

bitmap.font.color.set(255, 176, 144)

end

if type == 2

bitmap.font.color.set(255, 224, 128)

end

bitmap.draw_text(0, 12, 160, 36, damage_string, 1)

if critical

string = "CRITICAL"

bitmap.font.size = 20

bitmap.font.color.set(0, 0, 0)

bitmap.draw_text(-1, -1, 160, 20, string, 1)

bitmap.draw_text(+1, -1, 160, 20, string, 1)

bitmap.draw_text(-1, +1, 160, 20, string, 1)

bitmap.draw_text(+1, +1, 160, 20, string, 1)

bitmap.font.color.set(255, 255, 255)

bitmap.draw_text(0, 0, 160, 20, string, 1)

end

num = @_damage.size

if type != 2

@_damage.push([::Sprite.new, 40, 0, rand(40) - 20, rand(30) + 50])

else

@_damage.push([::Sprite.new, 40, 0, rand(20) - 10, rand(20) + 60])

end

@_damage[num][0].bitmap = bitmap

@_damage[num][0].ox = 80 + self.viewport.ox

@_damage[num][0].oy = 20 + self.viewport.oy

if self.battler.is_a?(Game_Actor)

@_damage[num][0].x = self.x

@_damage[num][0].y = self.y - self.oy / 2

else

@_damage[num][0].x = self.x + self.viewport.rect.x -

self.ox + self.src_rect.width / 2

@_damage[num][0].y = self.y - self.oy * self.zoom_y / 2 +

self.viewport.rect.y

@_damage[num][0].zoom_x = self.zoom_x

@_damage[num][0].zoom_y = self.zoom_y

@_damage[num][0].z = 3000

end

def animation(animation, hit)

return if animation == nil

num = @_animation.size

@_animation.push([animation, hit, animation.frame_max, []])

bitmap = RPG::Cache.animation(animation.animation_name,

animation.animation_hue)

if @@_reference_count.include?(bitmap)

@@_reference_count[bitmap] += 1

else

@@_reference_count[bitmap] = 1

end

if @_animation[num][0].position != 3 or

not @@_animations.include?(animation)

for i in 0..15

sprite = ::Sprite.new

sprite.bitmap = bitmap

sprite.visible = false

@_animation[num][3].push(sprite)

end

unless @@_animations.include?(animation)

@@_animations.push(animation)

end

update_animation(@_animation[num])

end

def loop_animation(animation)

return if animation == @_loop_animation

dispose_loop_animation

@_loop_animation = animation

return if @_loop_animation == nil

@_loop_animation_index = 0

animation_name = @_loop_animation.animation_name

animation_hue = @_loop_animation.animation_hue

bitmap = RPG::Cache.animation(animation_name, animation_hue)

if @@_reference_count.include?(bitmap)

@@_reference_count[bitmap] += 1

else

@@_reference_count[bitmap] = 1

end

@_loop_animation_sprites = []

for i in 0..15

sprite = ::Sprite.new

sprite.bitmap = bitmap

sprite.visible = false

@_loop_animation_sprites.push(sprite)

end

# update_loop_animation

end

def dispose_damage

for damage in @_damage.reverse

damage[0].bitmap.dispose

damage[0].dispose

@_damage.delete(damage)

end

def dispose_animation

for anime in @_animation.reverse

sprite = anime[3][0]

if sprite != nil

@@_reference_count[sprite.bitmap] -= 1

if @@_reference_count[sprite.bitmap] == 0

sprite.bitmap.dispose

end

for sprite in anime[3]

sprite.dispose

end

@_animation.delete(anime)

end

def effect?

@_whiten_duration > 0 or

@_appear_duration > 0 or

@_escape_duration > 0 or

@_collapse_duration > 0 or

@_damage.size == 0 or

@_animation.size == 0

end

def update

super

if @_whiten_duration > 0

@_whiten_duration -= 1

self.color.alpha = 128 - (16 - @_whiten_duration) * 10

end

if @_appear_duration > 0

@_appear_duration -= 1

self.opacity = (16 - @_appear_duration) * 16

end

if @_escape_duration > 0

@_escape_duration -= 1

self.opacity = 256 - (32 - @_escape_duration) * 10

end

if @_collapse_duration > 0

@_collapse_duration -= 1

self.opacity = 256 - (48 - @_collapse_duration) * 6

end

for damage in @_damage

if damage[1] > 0

damage[1] -= 1

damage[4] -= 3

damage[2] -= damage[4]

if self.battler.is_a?(Game_Actor)

damage[0].x = self.x + (40 - damage[1]) * damage[3] / 10

damage[0].y = self.y - self.oy / 2 + damage[2] / 10

else

damage[0].x = self.x + self.viewport.rect.x -

self.ox + self.src_rect.width / 2 +

(40 - damage[1]) * damage[3] / 10

damage[0].y = self.y - self.oy * self.zoom_y / 2 +

self.viewport.rect.y + damage[2] / 10

damage[0].zoom_x = self.zoom_x

damage[0].zoom_y = self.zoom_y

end

damage[0].z = 2960 + damage[1]

damage[0].opacity = 256 - (12 - damage[1]) * 32

if damage[1] == 0

damage[0].bitmap.dispose

damage[0].dispose

@_damage.delete(damage)

end

for anime in @_animation

if (Graphics.frame_count % 2 == 0)

anime[2] -= 1

update_animation(anime)

end

if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)

update_loop_animation

@_loop_animation_index += 1

@_loop_animation_index %= @_loop_animation.frame_max

end

if @_blink

@_blink_count = (@_blink_count + 1) % 32

if @_blink_count < 16

alpha = (16 - @_blink_count) * 6

else

alpha = (@_blink_count - 16) * 6

end

self.color.set(255, 255, 255, alpha)

end

@@_animations.clear

end

def update_animation(anime)

if anime[2] > 0

frame_index = anime[0].frame_max - anime[2]

cell_data = anime[0].frames[frame_index].cell_data

position = anime[0].position

animation_set_sprites(anime[3], cell_data, position)

for timing in anime[0].timings

if timing.frame == frame_index

animation_process_timing(timing, anime[1])

end

else

@@_reference_count[anime[3][0].bitmap] -= 1

if @@_reference_count[anime[3][0].bitmap] == 0

anime[3][0].bitmap.dispose

end

for sprite in anime[3]

sprite.dispose

end

@_animation.delete(anime)

end

def animation_set_sprites(sprites, cell_data, position)

for i in 0..15

sprite = sprites

pattern = cell_data[i, 0]

if sprite == nil or pattern == nil or pattern == -1

sprite.visible = false if sprite != nil

next

end

sprite.visible = true

sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)

if position == 3

if self.viewport != nil

sprite.x = self.viewport.rect.width / 2

if $game_temp.in_battle and self.battler.is_a?(Game_Enemy)

sprite.y = self.viewport.rect.height - 320

else

sprite.y = self.viewport.rect.height - 160

end

else

sprite.x = 320

sprite.y = 240

end

else

sprite.x = self.x + self.viewport.rect.x -

self.ox + self.src_rect.width / 2

if $game_temp.in_battle and self.battler.is_a?(Game_Enemy)

sprite.y = self.y - self.oy * self.zoom_y / 2 +

self.viewport.rect.y

if position == 0

sprite.y -= self.src_rect.height * self.zoom_y / 4

elsif position == 2

sprite.y += self.src_rect.height * self.zoom_y / 4

end

else

sprite.y = self.y + self.viewport.rect.y -

self.oy + self.src_rect.height / 2

sprite.y -= self.src_rect.height / 4 if position == 0

sprite.y += self.src_rect.height / 4 if position == 2

end

sprite.x += cell_data[i, 1]

sprite.y += cell_data[i, 2]

sprite.z = 2000

sprite.ox = 96

sprite.oy = 96

sprite.zoom_x = cell_data[i, 3] / 100.0

sprite.zoom_y = cell_data[i, 3] / 100.0

if position != 3

sprite.zoom_x *= self.zoom_x

sprite.zoom_y *= self.zoom_y

end

sprite.angle = cell_data[i, 4]

sprite.mirror = (cell_data[i, 5] == 1)

sprite.opacity = cell_data[i, 6] * self.opacity / 255.0

sprite.blend_type = cell_data[i, 7]

end

def x=(x)

sx = x - self.x

if sx != 0

for anime in @_animation

if anime[3] != nil

for i in 0..15

anime[3].x += sx

end

if @_loop_animation_sprites != nil

for i in 0..15

@_loop_animation_sprites.x += sx

end

super

end

def y=(y)

sy = y - self.y

if sy != 0

for anime in @_animation

if anime[3] != nil

for i in 0..15

anime[3].y += sy

end

if @_loop_animation_sprites != nil

for i in 0..15

@_loop_animation_sprites.y += sy

end

super

end

#------------------------------------------------------------------------------

# New routine added to the Bitmap class.

#==============================================================================

class Bitmap

#--------------------------------------------------------------------------

# * Rectangle Gradation Indicator

# color1: Start color

# color2: Ending color

# align: 0: On side gradation

# 1: Vertically gradation

# 2: The gradation (intense concerning slantedly heavily note)

#--------------------------------------------------------------------------

def gradation_rect(x, y, width, height, color1, color2, align = 0)

if align == 0

for i in x...x + width

red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)

green = color1.green +

(color2.green - color1.green) * (i - x) / (width - 1)

blue = color1.blue +

(color2.blue - color1.blue) * (i - x) / (width - 1)

alpha = color1.alpha +

(color2.alpha - color1.alpha) * (i - x) / (width - 1)

color = Color.new(red, green, blue, alpha)

fill_rect(i, y, 1, height, color)

end

elsif align == 1

for i in y...y + height

red = color1.red +

(color2.red - color1.red) * (i - y) / (height - 1)

green = color1.green +

(color2.green - color1.green) * (i - y) / (height - 1)

blue = color1.blue +

(color2.blue - color1.blue) * (i - y) / (height - 1)

alpha = color1.alpha +

(color2.alpha - color1.alpha) * (i - y) / (height - 1)

color = Color.new(red, green, blue, alpha)

fill_rect(x, i, width, 1, color)

end

elsif align == 2

for i in x...x + width

for j in y...y + height

red = color1.red + (color2.red - color1.red) *

((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

green = color1.green + (color2.green - color1.green) *

((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

blue = color1.blue + (color2.blue - color1.blue) *

((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

alpha = color1.alpha + (color2.alpha - color1.alpha) *

((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

color = Color.new(red, green, blue, alpha)

set_pixel(i, j, color)

end

elsif align == 3

for i in x...x + width

for j in y...y + height

red = color1.red + (color2.red - color1.red) *

((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

green = color1.green + (color2.green - color1.green) *

((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

blue = color1.blue + (color2.blue - color1.blue) *

((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

alpha = color1.alpha + (color2.alpha - color1.alpha) *

((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2

color = Color.new(red, green, blue, alpha)

set_pixel(i, j, color)

end

Any help would be greatly appreciated! Thanks.

Edited August 7, 2011 by Tethius

Tethius · August 7, 2011

Bump

Sign In

Need help with battle script.

Recommended Posts

Tethius 0

Share this post

Link to post

Share on other sites

Tethius 0

Share this post

Link to post

Share on other sites

Please sign in to comment

Recently Browsing 0 members

Browse