Advanced side-view battle system (does not require battlers)

JoelCMJ · March 06, 2007, 01:38:54 PM

Holy crap! The link aint working cuz the dude has left! Someone please send me the script if they still have it! I need it desprately

Irgna · March 07, 2007, 12:32:02 PM

I have it, but can't send it to you right now. I might be able to send it to you tonight or tomorrow, is that ok? Also, I'm making custom battle backs for it if anyone's interested.

Slayer · March 26, 2007, 12:44:11 AM

I need this script as well.

bulls84 · March 26, 2007, 01:00:40 AM

Quote from: Irgna on March 07, 2007, 12:32:02 PM
I have it, but can't send it to you right now. I might be able to send it to you tonight or tomorrow, is that ok? Also, I'm making custom battle backs for it if anyone's interested.

Nice, i need some battle backs for this script

Irgna · March 26, 2007, 01:35:30 AM

Here are the backdrops (attached). I cannot find the script, sorry.

bulls84 · March 26, 2007, 01:39:21 AM

[spoiler][code]class Bitmap
if not method_defined?('original_draw_text')
alias original_draw_text draw_text
def draw_text(*arg)

original_color = self.font.color.dup
self.font.color = Color.new(0, 0, 0, 128)

if arg[0].is_a?(Rect)
arg[0].x += 2
arg[0].y += 2
self.original_draw_text(*arg)
arg[0].x -= 2
arg[0].y -= 2
else
arg[0] += 2
arg[1] += 2
self.original_draw_text(*arg)
arg[0] -= 2
arg[1] -= 2
end

self.font.color = original_color
self.original_draw_text(*arg)

end
end
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
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
end
end
end
end

module RPG
class Sprite < ::Sprite
def damage(value, critical)
dispose_damage
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
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(255, 255, 255)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
end
@_damage_sprite = ::Sprite.new
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80 + self.viewport.ox
@_damage_sprite.oy = 20 + self.viewport.oy
@_damage_sprite.x = self.x + self.viewport.rect.x
@_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
@_damage_sprite.z = 3000
@_damage_duration = 40
end
def animation(animation, hit)
dispose_animation
@_animation = animation
return if @_animation == nil
@_animation_hit = hit
@_animation_duration = @_animation.frame_max
animation_name = @_animation.animation_name
animation_hue = @_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
@_animation_sprites = []
if @_animation.position != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_animation_sprites.push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation
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 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
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
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
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
end
end
end

class Game_Actor < Game_Battler
def screen_x
if self.index != nil
n_split = [($game_party.actors.length * 0.5).ceil, 4].min
case n_split
when 1
n_index = self.index * 2
when 2
if self.index < ($game_party.actors.length - 2)
n_index = 0.5 + (2 * self.index)
else
if $game_party.actors.length == 3 then
n_index = (self.index * 2) + 2
elsif $game_party.actors.length == 4 then
n_index = self.index * 2
end
end
when 3
n_index = self.index + (0.25 * (self.index + 1))
if $game_party.actors.length == 5
if self.index < 2
n_index = self.index + (0.25 * (self.index + 1))
else
n_index = self.index + (0.25 * (self.index + 2)) + 1
end
end
when 4
n_index = self.index
if $game_party.actors.length == 7
if self.index < 3
n_index = self.index
else
n_index = self.index + 1
end
end
end
return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) / 5) + 480 + ((n_index / 4).floor * 60)
else
return 0
end
end
#--------------------------------------------------------------------------
# ? ?? Y ??
#--------------------------------------------------------------------------
def screen_y
n_split = [($game_party.actors.length * 0.5).ceil, 4].min
case n_split
when 1
n_index = self.index * 2
when 2
if self.index < ($game_party.actors.length - 2)
n_index = 0.5 + (2 * self.index)
else
if $game_party.actors.length == 3 then
n_index = (self.index * 2) + 2
elsif $game_party.actors.length == 4 then
n_index = self.index * 2
end
end
when 3
n_index = self.index + (0.25 * (self.index + 1))
if $game_party.actors.length == 5
if self.index < 2
n_index = self.index + (0.25 * (self.index + 1))
else
n_index = self.index + (0.25 * (self.index + 2)) + 1
end
end
when 4
n_index = self.index
if $game_party.actors.length == 7
if self.index < 3
n_index = self.index
else
n_index = self.index + 1
end
end
end
return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) * 1.6) + 270 - ((n_index / 4).floor * (110 - (4 * 20)))
end
#--------------------------------------------------------------------------
# ? ?? Z ??
#--------------------------------------------------------------------------
def screen_z
# ?? Z
if self.index != nil
return self.index
else
return 0
end
end
end

class Game_Enemy < Game_Battler
def screen_x
n_split = [($game_troop.enemies.length * 0.5).ceil, 4].min
case n_split
when 1
n_index = self.index * 2
when 2
if self.index < ($game_troop.enemies.length - 2)
n_index = 0.5 + (2 * self.index)
else
if $game_troop.enemies.length == 3 then
n_index = (self.index * 2) + 2
elsif $game_troop.enemies.length == 4 then
n_index = self.index * 2
end
end
when 3
n_index = self.index + (0.25 * (self.index + 1))
if $game_troop.enemies.length == 5
if self.index < 2
n_index = self.index + (0.25 * (self.index + 1))
else
n_index = self.index + (0.25 * (self.index + 2)) + 2
end
end
when 4
n_index = self.index
if $game_troop.enemies.length == 7
if self.index < 3
n_index = self.index
else
n_index = self.index + 1
end
end
end
return (n_index - ((n_index / 4).floor) * 4) * ((-160 / (4)) / 5) + 160 - ((n_index / 4).floor * 60)
end
#--------------------------------------------------------------------------
# ? ?? Y ??
#--------------------------------------------------------------------------
def screen_y
n_split = [($game_troop.enemies.length * 0.5).ceil, 4].min
case n_split
when 1
n_index = self.index * 2
when 2
if self.index < ($game_troop.enemies.length - 2)
n_index = 0.5 + (2 * self.index)
else
if $game_troop.enemies.length == 3 then
n_index = (self.index * 2) + 2
elsif $game_troop.enemies.length == 4 then
n_index = self.index * 2
end
end
when 3
n_index = self.index + (0.25 * (self.index + 1))
if $game_troop.enemies.length == 5
if self.index < 2
n_index = self.index + (0.25 * (self.index + 1))
else
n_index = self.index + (0.25 * (self.index + 2)) + 1
end
end
when 4
n_index = self.index
if $game_troop.enemies.length == 7
if self.index < 3
n_index = self.index
else
n_index = self.index + 1
end
end
end
return (n_index - ((n_index / 4).floor) * 4) * ((160 / (4)) * 1.6) + 270 - ((n_index / 4).floor * (110 - (4 * 20)))
end
#--------------------------------------------------------------------------
# ? ?? Z ??
#--------------------------------------------------------------------------
def screen_z
return @member_index + 1
end
end

#==============================================================================
# ? Sprite_Battler
#------------------------------------------------------------------------------
# ??Game_Battler
# ??
#==============================================================================

class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# ? ?
#--------------------------------------------------------------------------
attr_accessor :battler # ?
attr_accessor :moving # Is the sprite moving?
attr_reader :index
attr_accessor :target_index
attr_accessor :direction
attr_accessor :pattern
#--------------------------------------------------------------------------
# ?
# viewport :
# battler : ? (Game_Battler)
#--------------------------------------------------------------------------
def initialize(viewport, battler = nil)
super(viewport)
change
@old = Graphics.frame_count # For the delay method
@goingup = true # Increasing animation? (if @rm2k_mode is true)
@once = false # Is the animation only played once?
@animated = true # Used to stop animation when @once is true
self.opacity = 0
@index = 0
@pattern_b = 0
@counter_b = 0
@trans_sprite = Sprite.new
@trans_sprite.opacity = 0
@bar_hp_sprite = Sprite.new
@bar_hp_sprite.bitmap = Bitmap.new(64, 10)
@bar_sp_sprite = Sprite.new
@bar_sp_sprite.bitmap = Bitmap.new(64, 10)
@color1 = Color.new(0, 0, 0, 192)
@color2 = Color.new(255, 255, 192, 192)
@color3 = Color.new(0, 0, 0, 192)
@color4 = Color.new(64, 0, 0, 192)
@old_hp = -1
@old_sp = -1
@battler = battler
@battler_visible = false
@first = true
@pattern = 0
if $target_index == nil
$target_index = 0
end
@battler.is_a?(Game_Enemy) ? enemy_pose(0, 1) : pose(0, 1)
end
#--------------------------------------------------------------------------
# ? ??
#--------------------------------------------------------------------------
def dispose
if self.bitmap != nil
self.bitmap.dispose
end
if @trans_sprite.bitmap != nil
@trans_sprite.bitmap.dispose
end
@trans_sprite.dispose
@bar_hp_sprite.bitmap.dispose
@bar_hp_sprite.dispose
@bar_sp_sprite.bitmap.dispose
@bar_sp_sprite.dispose
super
end

def change(frames = 0, delay = 0, offx = 0, offy = 0, startf = 0, once = false)
@frames = frames
@delay = delay
@offset_x, @offset_y = offx, offy
@current_frame = startf
@once = once
@goingup = true
@animated = true
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update
bar_check = true if @_damage_duration == 1
super
@trans_sprite.blend_type = self.blend_type
@trans_sprite.color = self.color
if @_collapse_duration > 0
@trans_sprite.opacity = self.opacity
else
@trans_sprite.opacity = [self.opacity, 160].min
end
if (@_damage_duration == 0 and bar_check == true) or @first == true
@first = false if @first == true
bar_check = false
@bar_must_change = true
end
@bar_hp_sprite.opacity = self.opacity
@bar_sp_sprite.opacity = self.opacity
# ?? nil
if @battler == nil
self.bitmap = nil
@trans_sprite.bitmap = nil
loop_animation(nil)
return
end
# ??
if @battler.battler_name != @battler_name or
@battler.battler_hue != @battler_hue
#
@battler_name = @battler.battler_name
@battler_hue = @battler.battler_hue
if @battler.is_a?(Game_Actor)
@battler_name = @battler.character_name
@battler_hue = @battler.character_hue
@direction = 4
else
@direction = 6
end
self.bitmap = RPG::Cache.character(@battler_name, @battler_hue)
@width = bitmap.width / 4
@height = bitmap.height / 4
@frame_width = @width
@frame_height = @height
self.ox = @width / 2
self.oy = @height
@pattern = @current_frame
@direction = @offset_y
sx = @pattern * @width
sy = (@direction - 2) / 2 * @height
self.src_rect.set(sx, sy, @width, @height)
@current_frame = (@current_frame + 1) unless @frames == 0
@animated = false if @current_frame == @frames and @once
@current_frame %= @frames
@trans_sprite.bitmap = self.bitmap
@trans_sprite.ox = self.ox
@trans_sprite.oy = self.oy
@trans_sprite.src_rect.set(sx, sy, @width, @height)
# 0
if @battler.dead? or @battler.hidden
self.opacity = 0
@trans_sprite.opacity = 0
@bar_hp_sprite.opacity = 0
@bar_sp_sprite.opacity = 0
end
self.x = @battler.screen_x
self.y = @battler.screen_y
self.z = @battler.screen_z
end
change_sp_bar if @old_sp != @battler.sp
if delay(@delay) and @animated
@pattern = @current_frame
@direction = @offset_y
sx = @pattern * @width
sy = (@direction - 2) / 2 * @height
self.src_rect.set(sx, sy, @width, @height)
@current_frame = (@current_frame + 1) unless @frames == 0
@animated = false if @current_frame == @frames and @once
@current_frame %= @frames
@trans_sprite.ox = self.ox
@trans_sprite.oy = self.oy
@trans_sprite.src_rect.set(sx, sy, @width, @height)
end
# ? ID
if @battler.damage == nil and
@battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
# ??
#if @battler.is_a?(Game_Actor) and @battler_visible
# ??
#if $game_temp.battle_main_phase
#self.opacity += 3 if self.opacity < 255
#else
#self.opacity -= 3 if self.opacity > 207
#end
#end
# ??
if @battler.blink
blink_on
else
blink_off
end
#
unless @battler_visible
# ??
if not @battler.hidden and not @battler.dead? and
(@battler.damage == nil or @battler.damage_pop)
appear
@battler_visible = true
end
end
# ??
if @battler_visible
# ??
if @battler.hidden
$game_system.se_play($data_system.escape_se)
escape
@trans_sprite.opacity = 0
@battler_visible = false
end
#
if @battler.white_flash
whiten
@battler.white_flash = false
end
# ?
if @battler.animation_id != 0
animation = $data_animations[@battler.animation_id]
animation(animation, @battler.animation_hit)
@battler.animation_id = 0
end
# ?
if @battler.damage_pop
damage(@battler.damage, @battler.critical)
@battler.damage = nil
@battler.critical = false
@battler.damage_pop = false
end
if @bar_must_change == true
@bar_must_change = false
if @old_hp != @battler.hp
change_hp_bar
end
if @battler.damage == nil and @battler.dead?
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
end
end
# ??
@trans_sprite.x = self.x
@trans_sprite.y = self.y
@trans_sprite.z = self.z
@bar_hp_sprite.x = @battler.screen_x - 32
@bar_hp_sprite.y = @battler.screen_y - (@height +18) if @height != nil
@bar_hp_sprite.z = 100
@bar_sp_sprite.x = @battler.screen_x - 32
@bar_sp_sprite.y = @battler.screen_y - (@height + if @height != nil
@bar_sp_sprite.z = 100
end

#--------------------------------------------------------------------------
# - Move the sprite
# x : X coordinate of the destination point
# y : Y coordinate of the destination point
# speed : Speed of movement (0 = delayed, 1+ = faster)
# delay : Movement delay if speed is at 0
#--------------------------------------------------------------------------
def move(x, y, speed = 1, delay = 0)
@destx = x
@desty = y
@move_speed = speed
@move_delay = delay
@move_old = Graphics.frame_count
@moving = true
end

#--------------------------------------------------------------------------
# - Move sprite to destx and desty
#--------------------------------------------------------------------------
def update_move
return unless @moving
movinc = @move_speed == 0 ? 1 : @move_speed
if Graphics.frame_count - @move_old > @move_delay or @move_speed != 0
self.x += movinc if self.x < @destx
self.x -= movinc if self.x > @destx
self.y += movinc if self.y < @desty
self.y -= movinc if self.y > @desty
@move_old = Graphics.frame_count
end
if @move_speed > 1 # Check if sprite can't reach that point
self.x = @destx if (@destx - self.x).abs % @move_speed != 0 and
(@destx - self.x).abs <= @move_speed
self.y = @desty if (@desty - self.y).abs % @move_speed != 0 and
(@desty - self.y).abs <= @move_speed
end
if self.x == @destx and self.y == @desty
@moving = false
end
end

#--------------------------------------------------------------------------
# - Pause animation, but still updates movement
# frames : Number of frames
#--------------------------------------------------------------------------
def delay(frames)
update_move
if (Graphics.frame_count - @old >= frames)
@old = Graphics.frame_count
return true
end
return false
end

def change_hp_bar
j = false
@old_hp = @battler.hp if @old_hp == -1
i = @old_hp
loop do
i -= 10
if i < @battler.hp
i = @battler.hp
j = true
end
rate = i.to_f / @battler.maxhp
@color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
@color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
@bar_hp_sprite.bitmap.clear
@bar_hp_sprite.bitmap.fill_rect(0, 0, 64, 10, @color1)
@bar_hp_sprite.bitmap.fill_rect(1, 1, 62, 8, @color2)
@bar_hp_sprite.bitmap.gradation_rect(2, 2, 60, 6, @color3, @color4, 1)
#@bar_hp_sprite.bitmap.fill_rect(2, 2, 60, 6, @color3)
@bar_hp_sprite.bitmap.gradation_rect(2, 2, 64 * rate - 4, 6, @color5, @color6, 0)
#@bar_hp_sprite.bitmap.fill_rect(2, 2, 64 * rate - 4, 6, @color5)
@bar_hp_sprite.opacity = self.opacity
Graphics.update
if j == true
j = false
break
end
end
@old_hp = @battler.hp
end

def change_sp_bar
j = false
@old_sp = @battler.sp if @old_sp == -1
i = @old_sp
loop do
i -= 10
if i < @battler.sp
i = @battler.sp
j = true
end
rate = i.to_f / @battler.maxsp
@color7 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
@color8 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
@bar_sp_sprite.bitmap.clear
@bar_sp_sprite.bitmap.fill_rect(0, 0, 64, 10, @color1)
@bar_sp_sprite.bitmap.fill_rect(1, 1, 62, 8, @color2)
@bar_sp_sprite.bitmap.gradation_rect(2, 2, 60, 6, @color3, @color4, 1)
#@bar_hp_sprite.bitmap.fill_rect(2, 2, 60, 6, @color3)
@bar_sp_sprite.bitmap.gradation_rect(2, 2, 64 * rate - 4, 6, @color7, @color8, 0)
#@bar_hp_sprite.bitmap.fill_rect(2, 2, 64 * rate - 4, 6, @color5)
@bar_sp_sprite.opacity = self.opacity
Graphics.update
if j == true
j = false
break
end
end
@old_sp = @battler.sp
end

def enemy #
$target_index += $game_troop.enemies.size
$target_index %= $game_troop.enemies.size
return $game_troop.enemies[$target_index] #
end #

def actor #
$target_index += $game_party.actors.size
$target_index %= $game_party.actors.size
return $game_party.actors[$target_index] #
end

def index=(index)
@index = index
update
end

def pose(number, frames = 4)
case number
when 0
change(frames, 4, 0, 4, 0)
when 1
change(frames, 4, 0, 4)
when 2
change(frames, 4, 0, 6)
else
change(frames, 4, 0, 0, 0)
end
end

def enemy_pose(number ,enemy_frames = 4)
case number
when 0
change(enemy_frames, 4, 0, 6, 0)
when 1
change(enemy_frames, 4, 0, 4)
when 2
change(enemy_frames, 4, 0, 6)
else
change(enemy_frames, 4, 0, 0, 0)
end
end

def default_pose
pose(0, 1)
end
end

#==============================================================================
# ? Spriteset_Battle
#------------------------------------------------------------------------------
# ?? Scene_Battle ??
#
#==============================================================================

class Spriteset_Battle
#--------------------------------------------------------------------------
# ? ?
#--------------------------------------------------------------------------
attr_reader :viewport1 #
attr_reader :viewport2 #
attr_accessor :actor_sprites
attr_accessor :enemy_sprites
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def initialize
#
@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
if $game_temp.battleback_name == ""
@battleback_sprite = nil
@tilemap = Tilemap.new(@viewport1)
@tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
for i in 0..6
autotile_name = $game_map.autotile_names
@tilemap.autotiles = RPG::Cache.autotile(autotile_name)
end
@tilemap.map_data = $game_map.data
@tilemap.priorities = $game_map.priorities
else
# ??
@tilemap = nil
@battleback_sprite = Sprite.new(@viewport1)
end
#
@enemy_sprites = []
for enemy in $game_troop.enemies#.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
end
#
@actor_sprites = []
for j in 0..7
# ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg,ð'Ç‰Á
@actor_sprites.push(Sprite_Battler.new(@viewport1, $game_party.actors[j]))
end
# ??
@weather = RPG::Weather.new(@viewport1)
#
@picture_sprites = []
for i in 51..100
@picture_sprites.push(Sprite_Picture.new(@viewport3,
$game_screen.pictures))
end
#
@timer_sprite = Sprite_Timer.new
#
update
end
#--------------------------------------------------------------------------
# ? ??
#--------------------------------------------------------------------------
def dispose
if @tilemap != nil
#
@tilemap.tileset.dispose
for i in 0..6
@tilemap.autotiles.dispose
end
@tilemap.dispose
end
# ??
if @battleback_sprite != nil
# ?
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
@battleback_sprite.dispose
end
# ?
for sprite in @enemy_sprites + @actor_sprites
sprite.dispose
end
# ??
@weather.dispose
#
for sprite in @picture_sprites
sprite.dispose
end
#
@timer_sprite.dispose
#
@viewport1.dispose
@viewport2.dispose
@viewport3.dispose
@viewport4.dispose
end
#--------------------------------------------------------------------------
# ? ?
#--------------------------------------------------------------------------
def effect?
# true
for sprite in @enemy_sprites + @actor_sprites
return true if sprite.effect?
end
return false
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update
# ??
if @battleback_sprite != nil
if @battleback_name != $game_temp.battleback_name
@battleback_name = $game_temp.battleback_name
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
bg_bitmap = RPG::Cache.battleback(@battleback_name)
bg_bitmap_stretch = Bitmap.new(640, 480)
bg_bitmap_stretch.stretch_blt(Rect.new(0, 0, 640, 480), bg_bitmap, bg_bitmap.rect)
@battleback_sprite.bitmap = bg_bitmap_stretch
end
end
if @tilemap != nil
@tilemap.ox = $game_map.display_x / 4
@tilemap.oy = $game_map.display_y / 4
@tilemap.update
end
#
for sprite in @enemy_sprites + @actor_sprites
sprite.update
end
# ??
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.update
#
for sprite in @picture_sprites
sprite.update
end
#
@timer_sprite.update
#
@viewport1.tone = $game_screen.tone
@viewport1.ox = $game_screen.shake
#
@viewport4.color = $game_screen.flash_color
#
@viewport1.update
@viewport2.update
@viewport4.update
end
end

#==============================================================================
# ? Window_Command
#------------------------------------------------------------------------------
# ?
#==============================================================================

class Window_Command < Window_Selectable
#--------------------------------------------------------------------------
# ?
# width : ?
# commands : ?
#--------------------------------------------------------------------------
def initialize(width, commands, column_max = 1, style = 0, inf_scroll = 1)
# ??
super(0, 0, width, (commands.size * 1.0 / column_max).ceil * 32 + 32)
@inf_scroll = inf_scroll
@item_max = commands.size
@commands = commands
@column_max = column_max
@style = style
self.contents = Bitmap.new(width - 32, (@item_max * 1.0 / @column_max).ceil * 32)
self.contents.font.name = "Tahoma"
self.contents.font.size = 22
refresh
self.index = 0
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def refresh
self.contents.clear
for i in 0...@item_max
draw_item(i, normal_color)
end
end
#--------------------------------------------------------------------------
# ? ??
# index : ?
# color :
#--------------------------------------------------------------------------
def draw_item(index, color)
self.contents.font.color = color
rect = Rect.new(index%@column_max * (self.width / @column_max) + 4, 32 * (index/@column_max), self.width / @column_max - 40, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[index], @style)
end
#--------------------------------------------------------------------------
# ?
# index : ?
#--------------------------------------------------------------------------
def disable_item(index)
draw_item(index, disabled_color)
end

def update_help
@help_window.set_actor($game_party.actors[$scene.actor_index])
end
end

#==============================================================================
# ? Arrow_Enemy
#------------------------------------------------------------------------------
# Arrow_Base ??
# ??
#==============================================================================

class Arrow_Enemy < Arrow_Base
#--------------------------------------------------------------------------
# ? ??
#--------------------------------------------------------------------------
def enemy
return $game_troop.enemies[@index]
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update
super
# ?
$game_troop.enemies.size.times do
break if self.enemy.exist?
@index += 1
@index %= $game_troop.enemies.size
end
# ??
if Input.repeat?(Input::DOWN)
$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
end
# ??
if Input.repeat?(Input::UP)
$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
end
if Input.repeat?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += ((($game_troop.enemies.length) * 0.5).ceil)
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
end
if Input.repeat?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += $game_troop.enemies.size - ((($game_troop.enemies.length) * 0.5).ceil)
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
end
# ??
if self.enemy != nil
self.x = self.enemy.screen_x + 4
self.y = self.enemy.screen_y + 36
self.z = self.enemy.screen_z + 1
end
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update_help
#
@help_window.set_enemy(self.enemy)
end
end

#==============================================================================
# ? Arrow_Actor
#------------------------------------------------------------------------------
# Arrow_Base ??
# ??
#==============================================================================

class Arrow_Actor < Arrow_Base
#--------------------------------------------------------------------------
# ? ??
#--------------------------------------------------------------------------
def actor
return $game_party.actors[@index]
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update
super
# ??
if Input.repeat?(Input::DOWN)
$game_system.se_play($data_system.cursor_se)
@index += 1
@index %= $game_party.actors.size
end
# ??
if Input.repeat?(Input::UP)
$game_system.se_play($data_system.cursor_se)
@index += $game_party.actors.size - 1
@index %= $game_party.actors.size
end
if Input.repeat?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
@index += ($game_party.actors.length * 0.5).ceil
@index %= $game_party.actors.size
end
# ??
if Input.repeat?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
@index += $game_party.actors.size - (($game_party.actors.length * 0.5).ceil)
@index %= $game_party.actors.size
end
# ??
if self.actor != nil
self.x = self.actor.screen_x
self.y = self.actor.screen_y + 36
self.z = self.actor.screen_z + 1
end
end
#--------------------------------------------------------------------------
# ?
#--------------------------------------------------------------------------
def update_help
# ?
@help_window.set_actor(self.actor)
end
end

class Scene_Battle
attr_accessor :actor_index
def main
#
$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
#
$game_system.battle_interpreter.setup(nil, 0)
# ?
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
# ?
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(640, [s1, s2, s3, s4], 4)
@actor_command_window.y = 64
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
#
@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
# ??
@spriteset = Spriteset_Battle.new
#
@wait_count = 0
#
if $data_system.battle_transition == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$data_system.battle_transition)
end
# ??
start_phase1
#
loop do
# ??
Graphics.update
# ?
Input.update
#
update
# ?
if $scene != self
break
end
end
# ?
$game_map.refresh
#
Graphics.freeze
# ??
@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
# ??
@spriteset.dispose
#
if $scene.is_a?(Scene_Title)
# ?
Graphics.transition
Graphics.freeze
end
#
if $BTEST and not $scene.is_a?(Scene_Gameover)
$scene = nil
end
end

def update
# ?
if $game_system.battle_interpreter.running?
#
$game_system.battle_interpreter.update
# ?
if $game_temp.forcing_battler == nil
# ??
unless $game_system.battle_interpreter.running?
# ??
unless judge
setup_battle_event
end
end
# ?
if @phase != 5
# ??
#@status_window.refresh
end
end
end
# ? (?)
$game_system.update
$game_screen.update
# ?? 0
if $game_system.timer_working and $game_system.timer == 0
# ??
$game_temp.battle_abort = true
end
# ??
@help_window.update
@party_command_window.update
@actor_command_window.update
#@status_window.update
@message_window.update
# ??
@spriteset.update
# ?
if $game_temp.transition_processing
# ??
$game_temp.transition_processing = false
#
if $game_temp.transition_name == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$game_temp.transition_name)
end
end
# ?
if $game_temp.message_window_showing
return
end
# ??
if @spriteset.effect?
return
end
# ?
if $game_temp.gameover
# ??
$scene = Scene_Gameover.new
return
end
# ??
if $game_temp.to_title
# ??
$scene = Scene_Title.new
return
end
# ??
if $game_temp.battle_abort
# ? BGM
$game_system.bgm_play($game_temp.map_bgm)
# ??
battle_end(1)
&nbs

WhiteKnight · April 04, 2007, 06:41:00 PM

Ran into a little problem, hope someone can help.

I put the script in and it work fine. I tried to change the battle back to something that looks right with the side veiw and I got an error message. I tried to change it back...Same error... Took out the whole script again and guess what? Same error. Below is the error message screenie

http://img.photobucket.com/albums/v200/travskoot/Gah.jpg

=\

EDIT: I think that might be mostly I started in a saved game. I added the batteback again, started a new game and got a new error

Its a syntax error on line 1909 =(

WhiteKnight · April 05, 2007, 08:57:15 PM

Hate to do this but I really need this solved. *Bumpp*

WcW · April 08, 2007, 11:23:48 PM

This unfortunately happens every time this script is added into a game, and as far as I know it can't be fixed, so my advice is just to not use this script at all until you make a new game.

Kokowam · April 08, 2007, 11:25:08 PM

He really does need this solved... Lots of maps already made...

WcW · April 08, 2007, 11:40:59 PM

Well, actually, I might have a way. Give me a sec to figure this out.

WcW · April 09, 2007, 12:08:25 AM

Yes, I might be on to something. Create a new game, change all the battlebacks, then install the script. The use the materialbase to upload anything you don't already have in the game. The next part will require manual re-formating.

Open the game folder for your original game, go to the data folder. To the same with the new game. MAKE SURE NOT TO GET THESE TWO CONFUSED, OR ELSE YOU WILL PAY. Copy the following files from the original and replace the ones in the new game with them:
Everything BUT scripts. Do this with all the files you have in the other two folders, and it should work. I'll test it right quick to make sure.

Irgna · April 09, 2007, 12:22:37 AM

Wierd, I never used to have that problem...

WhiteKnight · April 09, 2007, 03:22:27 AM

I get a "Bad Value For Range" error when I get into battle now.

Did all you said.

I tried it out in a new game and it work fine other then the fact that did battleback didn't change. I had it set to one of the ones downloaded from this thread.

Irgna · April 09, 2007, 12:26:56 PM

I don't know what's wrong, I never had those kinds of problems with this script...

WcW · April 09, 2007, 02:39:33 PM

I looked into it, there's no way to solve it. You'll have to get someone good at scripting to take a look at it, I guess.

Irgna · April 09, 2007, 02:43:28 PM

*cough*Blizzard*cough*

WhiteKnight · April 09, 2007, 06:31:31 PM

*sigh* Hopfully Blizz see's this... Should I just PM him?

WcW · April 09, 2007, 08:39:55 PM

Hmm... Strange how I was coughing the word Blizz in my head at the same time Irgna was coughing it aloud...

WhiteKnight · April 09, 2007, 09:37:26 PM

I have been on this site for all of three days and that was the first thing that came to my head **Blizzard**

Haha, look for 5 mins in this section and you can tell he's the man when it comes to scripts.

Decadent Sympozium · April 11, 2007, 08:12:45 AM

USUALLY when ABS don't work for me I delete the lone SDK script and the problems vanish.

...

Just a thought.

WcW · April 11, 2007, 08:40:39 PM

This, however, is NOT an ABS.

Irgna · April 11, 2007, 08:42:52 PM

Correct, it's a SVBS (Side-View Battle System).

Kokowam · April 11, 2007, 08:52:34 PM

An advanced SVBS.

Also, if my game/script doesn't get helped with, then I'm going to make a new project and use this

Maybe I'll use this anyways.

WhiteKnight · April 12, 2007, 01:51:23 AM

So just to clarify, i'm not the only one getting this error/getting bugs?