Login at Creare Videogiochi

seingh · 01-05-2010, 09:57 AM

Bs laterale a 11 pose

Descrizione
Questo script vi permetterà di avere un combattimento molto simile alla final fantasy
utilizzando dei chara a 11 pose

Autore

Darkshiva e nello script c'è il nik dell'altro forum(yourff.it)Petryx

Script

Codice:
#==============================================================================

# ** Animated Battlers - Enhanced ver. 5.0 (12-23-2006)

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

# Animated Battlers by Petryx

# Salve!!Per creare questo script ci ho impiegato la

#bellezza di 3 settimane,ma ne è valsa la pena cosi 

#per chi volesse creare un gioco a chara animati a

#undici pose ora lo può fare grazie a questo script.

#Ora passiamo alle istrizzioni per farlo funzionare:

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

#                          ISTRUZZIONI ALL'USO

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

#Bene ora per iniziare dobbiamo copiare questo script sopra a main

#e lo dovete chiamare Animated Battlers e non diversamente altrimenti 

#non funziona.Poi dobbiamo andare a scaricare i chara a undici pose e 

#lo possiamo fare da questo sito 

#http://rpgcreative.net/b_ressources/categorie-rmxp-cbs.html

#dopa aver scaricati chara che vi piacciono,li dovete copiarli tutti  

#in battleres.Per domande eventuali riferirsi sotto al mio post nel forum.

#                          BUON DIVERTIMENTO

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

# ** Sprite_Battler

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

# This sprite is used to display the battler.It observes the Game_Character

# class and automatically changes sprite conditions.

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

class Sprite_Battler < RPG::Sprite

attr_accessor :battler_offset # Degree of action forcing

attr_accessor :skill_used # Degree of action forcing

attr_accessor :item_used # Degree of action forcing

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

# * Initialize

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

alias cbs_initialize initialize

def initialize(viewport, battler = nil)

# * Configuration System *

# * Default Battler Style Switches

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

$default_enemy = false # If true, these switches allows the use

$default_actor = false # of default battlers for actors/enemies

$default_enemy_id = [] # Ids of enemies using default battlers

$default_actor_id = [] # Ids of actors using default battlers

@default_collapse_actor = false # If true, restores the old 'red fade'

@default_collapse_enemy = true # collapse effect (using spritesheets)

# * Animation Frames and Animation Speed

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

@speed = 4 # Framerate speed of the battlers

@poses = 11 # Maximum # of poses (stances) in the template

@frames = 4 # Maximum # of frames in each pose

@frames_standard = 4 # Standard # of frames played in each pose.

@low_hp_percentage = 0.25 # Determines health% of battler for WOOZY pose.

# * Poses Control

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

# Editable Template (Some people wanted to change their template design)

$p0 = 0 # sets the 'Ready pose' ($p0) to be pose #0 in your template

$p1 = 1 # Sets the 'Ready Pose' ($p1) to be pose #1 in your template

$p2 = 2 # Sets the 'Struck Pose' ($p2) to be pose #2 in your template

$p3 = 3 # Sets the 'Woozy Pose' ($p3) to be pose #3 in your template

$p4 = 4 # Sets the 'Block Pose' ($p4) to be pose #4 in your template

$p5 = 5 # Sets the 'Charge Pose' ($p5) to be pose #5 in your template

$p6 = 6 # Sets the 'Retreat Pose'($p6) to be pose #6 in your template

$p7 = 7 # Sets the 'Attack Pose' ($p7) to be pose #7 in your template

$p8 = 8 # Sets the 'Item Pose' ($p8) to be pose #8 in your template

$p9 = 9 # Sets the 'Skill Pose' ($p9) to be pose #9 in your template

$p10 = 10 # Sets the 'Victory Pose'($p10)to be pose #10 in your template

$p11 = 11 # Sets the 'Defeat Pose' ($p11)to be pose #11 in your template

# Non-Default Poses (can expand beyond the default 11 poses here)

@poses_setup = nil # Choose animation pose for 'preparation'

@poses_casting = nil # Set casting pose to 'Block' for example

$poses_escaping = nil # Set 'coward' pose for fleeing monsters)

$poses_critical = nil # Set 'critical' hit pose for BIG hits.

@poses_dying = nil # Choose animation pose for dying throws.

@poses_winning = nil # Set winning dance to 'block' for examp.

@poses_winning_loops = [] # Set victory non-freezing actor as #7

# Non-Default Pose Hashes (poses dependant on .id values)

@poses_status = {} # Didn't set any

$poses_skills = {} # Didn't set any

$poses_items = {} # Didn't set any

$poses_weapons = {} # Didn't set any weapons to any poses

# * Frames Control

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

@frames_per_pose = {0 => 1, 4 => 1} # Set #of frames to pose(by index)

# 1 frame set for 0(Victory) and

# set for 4 (Defeat). All other

# poses are animated.

# Advanced Individual Pose/Frame Hashes # Advanced Individual Poses uses

# hashes within hashes.

$poses_actor = {} #

$poses_enemy = {} #

#

# Individual Battler Settings

@mirror_enemies = true # Enemy battlers use reversed image

@stationary_enemies = false # If the enemies don't move while attacking

@stationary_actors = false # If the actors don't move while attacking

@calculate_speed = false # System calculates a mean/average speed

@phasing = false # Characters fade in/out while attacking

# * Movement Settings (Step-Forward / Final Fantasy-Style)

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

$rush_offset = 0 # How much additional space between battlers

$rush_attack = false # If true, battler steps forward to attack

$rush_skill = true # If true, battler steps forward to use skill

$rush_item = true # If true, battler steps forward to use item

# * Movement Arrays (Arrays for skill/weapon/item IDs that affect movement)

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

$moving_item_atk = [1] # Examples are items that need to be applied.

$moving_skill_atk = [57,61] # Examples are martial-arts and sneak attacks

$move2center_atk = [] # Moves battler to center based on weapon id!

$move2center_item = [5] # Moves battler to center for a big item atk!

$move2center_skill = [7] # Moves battler to center for a big skill atk!

# * Stationary Arrays (Arrays for skill/weapon/item IDs that halt movement)

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

# Array that holds the id # of skills, items or weapons that affect movement

$stationary_enemyid = [] # Enemies that don't RUN during melee attacks

@stationary_weapons = [17,18,19,20,21,22,23,24] # (examples are bows & guns)

@stationary_skills = [] # (examples are bows & guns)

@stationary_items = [] # (examples are bows & guns)

# Adaptation Switches

$RTAB_Connected_Attacking = false # Needed to be on if RTAB and Con. Attk.

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

# DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU'RE DOING

@frame, @pose = 0, 0

@last_time = 0

@last_move_time = 0

@battler_offset = 0

@skill_used = 9

@item_used = 0

$casted = false

$casting = false

@dying = true

@s_pose = false

$victory = false

@winning = true

cbs_initialize(viewport, battler)

viewport.z = 99

$formation = $formation_style

# Setting values called from EVENT scripts

$sv_mirror = $sideview_mirror

$sv_mirror = 0 if $sideview_mirror == nil

$max_member = $formation_max_member

$max_member = 4 if $formation_max_member == nil

$formation_top = $formation_max_height

$formation_top = 220 if $formation_max_height == nil

$formation_width = $formation_max_width

$formation_width = 128 if $formation_max_width == nil

$battlestat_height = $battlestatus_height

$battlestat_height = 160 if $battlestatus_height == nil

$formation = $formation_style

$formation = 0 if $formation_style == nil

# if Formation is random

if $formation == 8 then

$formation = rand(8).to_i

end

end

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

# * Update

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

alias cbs_update update

def update

return unless @battler

# Regular Update

cbs_update

# Reset hash for Advanced Pose/Frames

pose_temp = {}

# Start Routine

unless @started

@pose = state

if @battler.is_a?(Game_Enemy)

if not $default_enemy

if $default_enemy_id == nil

# Set up Spritesheet Standards

@width = @width / @frames

@height = @height / @poses

else

if not $default_enemy_id.include?(@battler.id)

@width = @width / @frames

@height = @height / @poses

end

end

end

end

if @battler.is_a?(Game_Actor)

if not $default_actor

if $default_actor_id == nil

# Set up Spritesheet Standards

@width = @width / @frames

@height = @height / @poses

else

if not $default_actor_id.include?(@battler.id)

@width = @width / @frames

@height = @height / @poses

end

end

end

end

@battler_offset = @width * 0.75

@display_x = @battler.screen_x

@display_y = @battler.screen_y

@display_z = @battler.screen_z

@destination_x = @display_x

@destination_y = @display_y

@destination_z = @display_z

self.opacity = 0

@started = true

end

# Cut Out Frame

# Enemy Battler Routine

if @battler.is_a?(Game_Enemy)

if $default_enemy

self.src_rect.set(@width * 0, @height * 0, @width, @height)

else

if $default_enemy_id !=nil

if $default_enemy_id.include?(@battler.id)

self.src_rect.set(@width * 0, @height * 0, @width, @height)

else

self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

end

else

self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

end

end

end

# Actor Battler Routine

if @battler.is_a?(Game_Actor)

if $default_actor

self.src_rect.set(@width * 0, @height * 0, @width, @height)

else

if $default_actor_id !=nil

if $default_actor_id.include?(@battler.id)

self.src_rect.set(@width * 0, @height * 0, @width, @height)

else

self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

end

else

self.src_rect.set(@width * @frame, @height * @pose, @width, @height)

end

end

end

# Position Sprite

self.x = @display_x

self.y = @display_y

self.z = @display_z

self.ox = @width / 2

self.oy = @height

# Adjust sprite direction if facing the other way...

if $sv_mirror == 1

if @battler.is_a?(Game_Actor)

self.mirror = !!battler

else

if not @mirror_enemies

self.mirror = !!battler

end

end

else

if @battler.is_a?(Game_Enemy)

if @mirror_enemies

self.mirror = !!battler

end

end

end

# Setup Frames per Pose

poseframe = @frames_standard

poseframe = @frames_per_pose[@pose] if @frames_per_pose.include?(@pose)

# Set Advanced Poses for Actors

if @battler.is_a?(Game_Actor)

pose_temp = $poses_actor[@battler.id] if $poses_actor.include?(@battler.id)

poseframe = pose_temp[@pose] if pose_temp.include?(@pose)

end

# Set Advanced Poses for Enemies

if @battler.is_a?(Game_Enemy)

pose_temp = $poses_enemy[@battler.id] if $poses_enemy.include?(@battler.id)

poseframe = pose_temp[@pose] if pose_temp.include?(@pose)

end

# Setup Animation

time = Graphics.frame_count / (Graphics.frame_rate / @speed)

if @last_time < time

@frame = (@frame + 1) % poseframe

if @frame == 0

if @freeze

@frame = poseframe - 1

return

end

@pose = state

end

end

@last_time = time

# Setup Dying Animation

if @battler.dead?

if @dying == true

@pose = state

@dying = false

end

else

if @battler.is_a?(Game_Actor)

if @poses_setup != nil

if @s_pose == false

@pose = @poses_setup

@s_pose = true

end

end

if $victory == true

if @winning == true

@pose = state

@winning = false

end

end

end

end

# Move It

move if moving

end

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

# * Current State

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

def state

# Damage State

if [nil,{}].include?(@battler.damage)

# Battler Fine

@state = $p0

# Battler Wounded

@state = $p3 if @battler.hp < @battler.maxhp * @low_hp_percentage

# Battler Status-Effect

for i in @battler.states

@state = @poses_status[i] if @poses_status.include?(i)

end

# If Battler Dead

if @battler.dead?

# If using default battlers or default collapse

if (@default_collapse_actor and @battler.is_a?(Game_Actor)) or

(@default_collapse_enemy and @battler.is_a?(Game_Enemy)) or

($default_actor and @battler.is_a?(Game_Actor)) or

($default_enemy and @battler.is_a?(Game_Enemy)) or

($default_enemy_id.include?(@battler.id) and @battler.is_a?(Game_Enemy)) or

($default_actor_id.include?(@battler.id) and @battler.is_a?(Game_Actor))

# Do absolutely nothing

else

# Use Poses system

if @poses_dying != nil

if @dying == true

@state = @poses_dying

else

@state = $p10

end

else

@state = $p10

end

# Fix Opacity

self.opacity = 255

end

end

end

# Casting State

if $casted

if @battler.rtp != 0

if @poses_casting != nil

@state = @poses_casting

end

end

end

# Victory State

if @battler.is_a?(Game_Actor)

if $victory

if @poses_winning != nil

if @winning == true

if not @battler.dead?

@state = @poses_winning

end

else

if not @battler.dead?

@state = $p9

if not @poses_winning_loops.include?(@battler.id)

@freeze = true

end

end

end

else

if not @battler.dead?

@state = $p9

if not @poses_winning_loops.include?(@battler.id)

@freeze = true

end

end

end

end

end

# Guarding State (not if dead OR in victory)

if not @battler.dead?

if not $victory

@state = $p3 if @battler.guarding?

end

end

# Moving State

if moving

# Adjust sprite direction if facing the other way...

if $sv_mirror == 1

# If enemy battler moving

if @battler.is_a?(Game_Enemy)

# Battler Moving Left

@state = $p4 if moving.eql?(0)

# Battler Moving Right

@state = $p5 if moving.eql?(1)

# Else actor battler moving

else

# Battler Moving Left

@state = $p4 if moving.eql?(0)

# Battler Moving Right

@state = $p5 if moving.eql?(1)

end

else

# If enemy battler moving

if @battler.is_a?(Game_Enemy)

# Battler Moving Left

@state = $p4 if moving.eql?(0)

# Battler Moving Right

@state = $p5 if moving.eql?(1)

# Else actor battler moving

else

# Battler Moving Left

@state = $p4 if moving.eql?(0)

# Battler Moving Right

@state = $p5 if moving.eql?(1)

end

end

end

# Return State

return @state

end

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

# * Move

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

def move

time = Graphics.frame_count / (Graphics.frame_rate.to_f / (@speed * 5))

if @last_move_time < time

# Pause for Animation

return if @pose != state

# Phasing

if @phasing

d1 = (@display_x - @original_x).abs

d2 = (@display_y - @original_y).abs

d3 = (@display_x - @destination_x).abs

d4 = (@display_y - @destination_y).abs

self.opacity = [255 - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max

end

# Calculate Difference

difference_x = (@display_x - @destination_x).abs

difference_y = (@display_y - @destination_y).abs

difference_z = (@display_z - @destination_z).abs

# Done? Reset, Stop

if [difference_x, difference_y].max.between?(0, 8)

@display_x = @destination_x

@display_y = @destination_y

@display_z = @destination_z

@pose = state

return

end

# Calculate Movement Increments

increment_x = increment_y = 1

if difference_x < difference_y

increment_x = 1.0 / (difference_y.to_f / difference_x)

elsif difference_y < difference_x

increment_y = 1.0 / (difference_x.to_f / difference_y)

end

increment_z = increment_y

# Calculate Movement Speed

if @calculate_speed

total = 0; $game_party.actors.each{ |actor| total += actor.agi }

speed = @battler.agi.to_f / (total / $game_party.actors.size)

increment_x *= speed

increment_y *= speed

increment_z *= speed

end

# Multiply and Move

multiplier_x = (@destination_x - @display_x > 0 ? 8 : -8)

multiplier_y = (@destination_y - @display_y > 0 ? 8 : -8)

multiplier_z = (@destination_z - @display_z > 0 ? 8 : -8)

@display_x += (increment_x * multiplier_x).to_i

@display_y += (increment_y * multiplier_y).to_i

@display_z += (increment_z * multiplier_z).to_i

end

@last_move_time = time

end

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

# * Set Movement

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

def setmove(destination_x, destination_y, destination_z)

unless (@battler.is_a?(Game_Enemy) and @stationary_enemies) or

(@battler.is_a?(Game_Actor) and @stationary_actors)

unless @stationary_weapons.include?(@battler.weapon_id) or

@stationary_skills.include?(@skill_used) or

@stationary_items.include?(@item_used)

@original_x = @display_x

@original_y = @display_y

@original_z = @display_z

@destination_x = destination_x

@destination_y = destination_y

@destination_z = destination_z

end

end

end

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

# * Movement Check

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

def moving

if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)

return (@display_x > @destination_x ? 0 : 1)

end

end

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

# * Set Pose

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

def pose=(pose)

@pose = pose

@frame = 4

end

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

# * Freeze

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

def freeze

@freeze = true

end

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

# * Fallen Pose

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

if @derv_anim_bat_stack.nil?

@derv_anim_bat_stack = true

alias cbs_collapse collapse

def collapse

if @default_collapse_enemy

cbs_collapse if @battler.is_a?(Game_Enemy)

end

if @default_collapse_actor

cbs_collapse if @battler.is_a?(Game_Actor)

end

if $default_enemy

cbs_collapse if @battler.is_a?(Game_Enemy)

end

if $default_actor

cbs_collapse if @battler.is_a?(Game_Actor)

end

if $default_enemy_id != nil

if $default_enemy_id.include?(@battler.id)

cbs_collapse if @battler.is_a?(Game_Enemy)

end

end

if $defend_actor.id != nil

if $default_actor_id.include?(@battler.id)

cbs_collapse if @battler.is_a?(Game_Actor)

end

end

end

end

end

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

# ** Game_System

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

# This class handles data surrounding the system. Backround music, etc.

# is managed here as well. Refer to "$game_system" for the instance of

# this class.

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

class Game_System

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

# * Public Instance Variables

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

attr_accessor :sideview_mirror

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

# * Object Initialization

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

alias initialize_cbs_customize initialize

def initialize

# Call original initialization process

initialize_cbs_customize

@sideview_mirror = 0

end

end

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

# ** Game_Actor

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

# This class handles the actor. It's used within the Game_Actors class

# ($game_actors) and refers to the Game_Party class ($game_party).

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

class Game_Actor

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

# * Actor X Coordinate

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

def screen_x

# Determine minimum horizontal space between battlers

x_spacer = $formation_width / $max_member

if self.index != nil

case $formation

when 0 # DIAGONAL PATTERN 1

if $sv_mirror == 1

return self.index * -x_spacer + (($max_member+1)*x_spacer) #202

else

return self.index * x_spacer + (640-(($max_member+1)*x_spacer))#450

end

when 1 # DIAGONAL PATTERN 2

if $sv_mirror == 1

return self.index * x_spacer + x_spacer #64

else

return self.index * -x_spacer + (640-x_spacer*2) #576

end

when 2 # 2-ROW SLANT

if $sv_mirror == 1

if self.index < ($max_member/2)

return self.index + (($max_member+1)*x_spacer) + (x_spacer * self.index)

else

return self.index + (x_spacer * self.index) - x_spacer * 0.5

end

else

if self.index < ($max_member/2)

return self.index + (640-(($max_member+1)* x_spacer)) + (-x_spacer * self.index)

else

return self.index + (640-((x_spacer*0.5)-x_spacer)) + (-x_spacer * self.index)

end

end

when 3 # 2 ROW - SLANT

if $sv_mirror == 1

if self.index < ($max_member/2)

return self.index + (x_spacer/2)+(($max_member+1)* x_spacer) + (-x_spacer * self.index)

else

return self.index + (($max_member+1)* x_spacer) + (-x_spacer * self.index)

end

else

if self.index < ($max_member/2)

return self.index + 442 + (x_spacer * self.index)

else

return self.index + 430 + (x_spacer * self.index)

end

end

when 4 # Column Pattern 1

if $sv_mirror == 1

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return self.index + ($max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * (self.index-1))

else

return self.index + ($max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * self.index)

end

else

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return self.index + 640-($max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * (self.index-1))

else

return self.index + 640-($max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * self.index)

end

end

when 5 # Column Pattern 2

if $sv_mirror == 1

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return self.index + ($max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * (self.index-1))

else

return self.index + ($max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * self.index)

end

else

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return self.index + 640-($max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * (self.index-1))

else

return self.index + 640-($max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * self.index)

end

end

when 6 # Wave Formation 1

if $sv_mirror == 1

if self.index < ($max_member/2)

return 170

else

return 90

end

else

if self.index < ($max_member/2)

return 470

else

return 550

end

end

else # Wave Formation 2

if $sv_mirror == 1

if self.index < ($max_member/2)

return 170

else

return 90

end

else

if self.index < ($max_member/2)

return 470

else

return 550

end

end

end

else

return 0

end

end

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

# * Actor Y Coordinate

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

def screen_y

# Determine minimum vertical space between battlers

y_spacer = (480 - $battlestat_height - $formation_top) / $max_member

if self.index != nil

case $formation

when 0

return self.index * (y_spacer*1.25) + $formation_top

when 1

return self.index * (y_spacer*1.25) + $formation_top

when 2

if self.index < ($max_member/2)

return $formation_top + ((y_spacer*2.5) * self.index)

else

return ($formation_top - (y_spacer*($max_member+1))) + ((y_spacer*2.5) * self.index) #was 60

end

when 3

if self.index < ($max_member/2)

return $formation_top + ((y_spacer*2.5) * self.index)

else

return ($formation_top - (y_spacer*($max_member+1))) + ((y_spacer*2.5) * self.index) # was 60

end

when 4

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return $formation_top + ($battlestat_height/2)

else

return $formation_top + ($battlestat_height/6)

end

when 5

if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )

return $formation_top + ($battlestat_height/6)

else

return $formation_top + ($battlestat_height /2)

end

when 6

if self.index < ($max_member/2)

return $formation_top + (y_spacer * 2.5 * self.index)

else

return $formation_top + (y_spacer * 2.5 * ((self.index) - ($max_member/2)))

end

else

if self.index < ($max_member/2)

return $formation_top + (y_spacer*2.5*(($max_member/2)-1))+ (y_spacer * 2.5 * -self.index)

else

return $formation_top + (y_spacer*2.5*(($max_member/2)-1)) + (y_spacer * 2.5 * -((self.index) - ($max_member/2)))

end

end

end

end

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

# * Actor Z Coordinate

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

def screen_z

return screen_y

end

end

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

# ** Game_Enemy

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

# This class handles enemies. It's used within the Game_Troop class

# ($game_troop).

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

class Game_Enemy < Game_Battler

def screen_x

if self.index != nil

if $sv_mirror == 1

return 640 - $data_troops[@troop_id].members[@member_index].x

else

return $data_troops[@troop_id].members[@member_index].x

end

end

end

end

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

# ** Scene_Battle

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

# This class performs battle screen processing.

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

class Scene_Battle

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

# * Make Skill Action Results (alias used to determine skill used)

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

alias make_skill_action_result_anim make_skill_action_result

def make_skill_action_result(battler = @active_battler, plus_id = 0)

@rtab = !@target_battlers

if $RTAB_Connected_Attacking

make_skill_action_result_anim(battler, plus_id)

else

@rtab ? make_skill_action_result_anim(battler) : make_skill_action_result_anim

end

@skill_used = @skill.id

end

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

# * Make Item Action Results (alias used to determine item used)

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

alias make_item_action_result_anim make_item_action_result

def make_item_action_result(battler = @active_battler)

@rtab = !@target_battlers

@rtab ? make_item_action_result_anim(battler) : make_item_action_result_anim

@item_used = @item.id

@item_usage = @item.scope

end

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

# * Frame Update (main phase step 1 : action preparation) (Casting Routine)

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

alias update_phase4_step1_anim update_phase4_step1

def update_phase4_step1(battler = @active_battler)

@rtab = !@target_battlers

if $rtab_detected == true

update_phase4_step1_anim(battler)

if battler.current_action.kind == 1 and

(not battler.current_action.forcing or @force != 2)

if battler.rtp != 0

$casted = true

end

end

else

update_phase4_step1_anim

end

end

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

# * Action Animation, Movement

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

alias cbs_update_phase4_step3 update_phase4_step3

def update_phase4_step3(battler = @active_battler)

@rtab = !@target_battlers

target = (@rtab ? battler.target : @target_battlers)[0]

# If enemy is a default battler

if battler.is_a?(Game_Enemy)

if $default_enemy

if @rtab then battler.white_flash = true end

if @rtab then battler.wait = 10 end

end

if $default_enemy_id != nil

if $default_enemy_id.include?(@battler.id)

if @rtab then battler.white_flash = true end

if @rtab then battler.wait = 10 end

end

end

end

# If actor is a default battler

if battler.is_a?(Game_Actor)

if $default_actor

if @rtab then battler.white_flash = true end

if @rtab then battler.wait = 10 end

end

if $default_actor_id != nil

if $default_actor_id.include?(@battler.id)

if @rtab then battler.white_flash = true end

if @rtab then battler.wait = 10 end

end

end

end

# Set values and poses based on Action

case battler.current_action.kind

when 0 # Attack

rush_type = $rush_attack

full_moving = true ; if rush_type; full_moving = false; end

if $move2center_atk.include?(battler.weapon_id); center_move=true ; end

if $stationary_enemyid.include?(battler.id) and battler.is_a?(Game_Enemy)

full_moving = false

center_move = false

rush_type = false

end

if battler.current_action.basic == 2

# If escaping, disable all movement

full_moving = false

center_move = false

rush_type = false

end

base_pose = $p7

base_pose = $poses_weapons[battler.weapon_id] if $poses_weapons.include?(battler.weapon_id)

if battler.current_action.basic == 2

base_pose = $poses_escaping if $poses_escaping != nil

end

when 1 # Skill

rush_type = $rush_skill

if $moving_skill_atk.include?(@skill_used) ; full_moving = true ; end

if $move2center_skill.include?(@skill_used) ; center_move = true ; end

base_pose = $p8

base_pose = $poses_skills[@skill_used] if $poses_skills.include?(@skill_used)

when 2 # Item

rush_type = $rush_item

if $moving_item_atk.include?(@item_used) or @item_scope == 1..2 ; full_moving = true ; end

if $move2center_item.include?(@item_used); center_move = true; end

base_pose = $p6

base_pose = $poses_items[@item_used] if $poses_items.include?(@item_used)

end

# Control Movement and use current pose

@moved = {} unless @moved

return if @spriteset.battler(battler).moving

if not (@moved[battler] or battler.guarding?)

offset = offset_value(battler)

if rush_type # Steps forward

@spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1, battler.screen_z)

end

if full_moving # Runs to target

@spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y - 1, target.screen_z + 10)

end

if center_move # Runs to center

@spriteset.battler(battler).setmove(320+(offset/4), battler.screen_y-1, battler.screen_z)

end

@moved[battler] = true

return

@spriteset.battler(battler).pose = base_pose

elsif not battler.guarding?

@spriteset.battler(battler).pose = base_pose

@spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y, battler.screen_z)

end

# Finish Up Skill and Item Use

case battler.current_action.kind

when 1

# Flag system that skill was used

$casted = false

$casting = false

@spriteset.battler(battler).skill_used = 0

when 2

# Flag system that item was used

@spriteset.battler(battler).item_used = 0

end

# Battle_Charge value for BattleCry script

$battle_charge = true

# Done

@moved[battler] = false

@rtab ? cbs_update_phase4_step3(battler) : cbs_update_phase4_step3

end

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

# * Offset Calculation

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

def offset_value(battler = @active_battler)

offst = @spriteset.battler(battler).battler_offset

offst += $rush_offset

if $sv_mirror == 1

offset = (battler.is_a?(Game_Actor) ? -(offst) : offst)

else

offset = (battler.is_a?(Game_Actor) ? offst : -(offst))

end

return offset

end

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

# * Hit Animation

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

alias cbs_update_phase4_step4 update_phase4_step4

def update_phase4_step4(battler = @active_battler)

for target in (@rtab ? battler.target : @target_battlers)

damage = (@rtab ? target.damage[battler] : target.damage)

critical = (@rtab ? target.critical[battler] : target.critical)

if damage.is_a?(Numeric) and damage > 0

@spriteset.battler(target).pose = $p1

if critical == true

@spriteset.battler(target).pose = $poses_critical if $poses_critical != nil

end

end

end

@rtab ? cbs_update_phase4_step4(battler) : cbs_update_phase4_step4

end

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

# * Victory Animation

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

alias cbs_start_phase5 start_phase5

def start_phase5

for actor in $game_party.actors

return if @spriteset.battler(actor).moving

end

for actor in $game_party.actors

unless actor.dead?

$victory = true

end

end

cbs_start_phase5

end

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

# * Change Arrow Viewport

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

alias cbs_start_enemy_select start_enemy_select

def start_enemy_select

cbs_start_enemy_select

@enemy_arrow.dispose

@enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)

@enemy_arrow.help_window = @help_window

end

end

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

# ** Spriteset_Battle

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

# This class brings together battle screen sprites. It's used within

# the Scene_Battle class.

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

class Spriteset_Battle

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

# * Change Enemy Viewport

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

alias cbs_initialize initialize

def initialize

cbs_initialize

if @real_zoom != nil

$rtab_detected = true

end

@enemy_sprites = []

for enemy in $game_troop.enemies.reverse

@enemy_sprites.push(Sprite_Battler.new(@viewport2, enemy))

end

end

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

# * Find Sprite From Battler Handle

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

def battler(handle)

for sprite in @actor_sprites + @enemy_sprites

return sprite if sprite.battler == handle

end

end

end

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

# ** Arrow_Base

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

# This sprite is used as an arrow cursor for the battle screen. This class

# is used as a superclass for the Arrow_Enemy and Arrow_Actor classes.

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

class Arrow_Base < Sprite

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

# * Reposition Arrows

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

alias cbs_initialize initialize

def initialize(viewport)

cbs_initialize(viewport)

self.ox = 14

self.oy = 10

end

end