Aiuto ATB

[raXor]

Salve Ragazzi !!

 

Volevo sapere se si può inserire in un BS diverso da quello originale l'ATB, se si come ??

(Uso il BS Minkoff a 11 pose)

 

Se dovesse servire posto lo script del BS che uso:

 

 

 

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

# ** 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 istruzioni per farlo funzionare:

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

# ISTRUZIONI 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 = 7 # 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 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

 

 

 

Plz aiutatemi !

[MasterSion]

Ti consiglio vivamente di scaricarti il ctb di charlie lee e impostarlo in modalità atb (c'è anche la"grandia Bar")

Oppure fatti una ricerca su google atb minkoff sicuramente trovi quello che cerchi.

[raXor]

Ti consiglio vivamente di scaricarti il ctb di charlie lee e impostarlo in modalità atb (c'è anche la"grandia Bar")

Oppure fatti una ricerca su google atb minkoff sicuramente trovi quello che cerchi.

 

Grazie ho trovato quello che mi serviva tramite google...xD

 

GRAZIE ANCORA !

[MasterSion]

Prego non c'è di che! Però prima di aprire sti topic (solitamente inutili) fate una cavolo di ricerca.