XP Battle Setup

I'm new here and to RPG Maker Xp. Can someone tell me how to make the battle setup to where the characters are on the right side of the screen while the enemies or on the left instead of the characters being one south of the screen and the enemies are one the north.

here is the script, for a side view battle system:

<sup>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‚ð’ljÁ
        @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)
      # ??</sup>
 

Thx. So where do I put it. I never fooled with the scripts before......

oo ok...dam we had a tut on how to insert scripts but...we ill tell you. In rpg maker xp press F11, then go down the list on the left the last one should be called MAIN, right click on main and click new(or w/e its called =/) then name it something about what your script is....so maybe SIde view battle system..then copy and paste that whole thing into the right empty section.

Is it supposed to look like this?

Code: [Select]

#==============================================================================  # ** Sideview System
# ** Sideview Battle System Unanimated
#------------------------------------------------------------------------------
# Ordaz , Paradox2D6 and Squall (Credits)
# Version 1.14
# 3/10/2006
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
SDK.log(' Unanimated Sideview Battle System', 'Ordaz', 1, '2006-10-03')

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
if SDK.state(" Unanimated Sideview Battle System") == true
#------------------------------------------------------------------------------
# * Actual Processing
#------------------------------------------------------------------------------
module SDVA

X_LINE = 400 # ????????????
Y_LINE = 225 # ????????????
X_SPACE = 20 # ?????????????
Y_SPACE = 30 # ?????????????
X_POSITION = 50 # ??[????????]????
Y_POSITION = 0 # ??[????????]????

ATTACK_MOVE = true # ???????????( true / false )
SKILL_MOVE = false # ??????????????( true / false )
ITEM_MOVE = false # ???????????????( true / false )
MOVE_STEP = 3 # ????
MOVE_PIXEL = 10 # ???????????

PARTY_POS = 1 # ?????????( 0:? / 1:? / 2:? / 3:? )

WINDOWPOS_CHANGE = true # ??????????????????????( true / false )

end

#==============================================================================
# ? Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ? Draw X Coordinate
#--------------------------------------------------------------------------
def screen_x
if self.index != nil
# ?????
pos = $data_classes[self.class_id].position
x_pos = pos * SDVA::X_POSITION
scr_x = self.index * SDVA::X_SPACE + SDVA::X_LINE + x_pos
# ??????????
if self.current_action.move_action == true
# ????
scr_x += @shift_x
end
return scr_x
else
return 0
end
end
#--------------------------------------------------------------------------
# ?Draw Y Coordinate
#--------------------------------------------------------------------------
def screen_y
if self.index != nil
# ?????
pos = $data_classes[self.class_id].position
y_pos = pos * SDVA::Y_POSITION
scr_y = self.index * SDVA::Y_SPACE + SDVA::Y_LINE + y_pos
# ??????????
if self.current_action.move_action == true
# ????
scr_y += @shift_y
end
return scr_y
else
return 0
end
end
#--------------------------------------------------------------------------
# ? Draw Z Coordinate
#--------------------------------------------------------------------------
def screen_z
if self.index != nil
return self.index
else
return 0
end
end
end

#==============================================================================
# ? Game_Battler (???? 1)
#==============================================================================

class Game_Battler
#------------------------------------------------------------------------------
# *  Public Variables
#------------------------------------------------------------------------------
attr_reader :pattern # ??????
attr_reader :trans_x # X???????
attr_reader :moving # ??????
#--------------------------------------------------------------------------
# ? Initialize Battle
#--------------------------------------------------------------------------
alias initialize_sdva initialize
def initialize
initialize_sdva
move_reset
end
#--------------------------------------------------------------------------
# ? Move Process
#--------------------------------------------------------------------------
def move
@moving = 1
if @step < SDVA::MOVE_STEP
# ??????????
@pattern = (@pattern + 1) % 4
@step += 1
move_step
else
# ????
@pattern = 1
@moving = 2
end
end
#--------------------------------------------------------------------------
# ? Sets up the position of your character
#--------------------------------------------------------------------------
def move_step
# ???????????????????
case SDVA::PARTY_POS
when 0
@shift_y = @step * SDVA::MOVE_PIXEL
when 1
@shift_x = -(@step * SDVA::MOVE_PIXEL)
when 2
@shift_x = @step * SDVA::MOVE_PIXEL
when 3
@shift_y = -(@step * SDVA::MOVE_PIXEL)
end
end
#--------------------------------------------------------------------------
# ? Ending Movement module
#--------------------------------------------------------------------------
def move_reset
@moving = 0
@pattern = 0
@step = 0
@shift_x = 0
@shift_y = 0
end
end

#==============================================================================
# ? Game_BattleAction
#==============================================================================

class Game_BattleAction
#--------------------------------------------------------------------------
# ? Public Insurance Variables
#--------------------------------------------------------------------------
attr_accessor :move_action # ??????????
#--------------------------------------------------------------------------
# ? Clear The System
#--------------------------------------------------------------------------
alias clear_sdva clear
def clear
clear_sdva
@move_action = false
end
end

#==============================================================================
# ? Sprite_Battler
#==============================================================================

class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
alias update_sdva update
def update
# ????????????????
if @battler.is_a?(Game_Actor)
# ????????????????????
# ??????
if @battler.battler_name != @battler_name or
@battler.battler_hue != @battler_hue or
@battler.current_action.basic == 0 or
@battler.current_action.kind != 3
# ????????????
@character_name = @battler.character_name
@character_hue = @battler.character_hue
# ???????????
self.bitmap = RPG::Cache.character(@character_name, @character_hue)
cw = self.bitmap.width / 4
ch = self.bitmap.height / 4
@width = cw
@height = ch
if @battler.current_action.move_action == true
# ????
@battler.move
else
@battler.move_reset
end
# ?????????
sx = @battler.pattern * cw
sy = SDVA::PARTY_POS * ch
self.src_rect.set(sx, sy, cw, ch)
self.ox = @width / 2
self.oy = @height
# ??????????? 0 ???
if @battler.hidden
self.opacity = 0
end
end
end
update_sdva
end
end

#==============================================================================
# ? Scene_Battle
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# ? Initializing the windows and the Bars
#--------------------------------------------------------------------------
alias phase3_setup_command_window_sdva phase3_setup_command_window
def phase3_setup_command_window
phase3_setup_command_window_sdva
if SDVA::WINDOWPOS_CHANGE
# ???????????????????
case SDVA::PARTY_POS
when 0
x_pos = @active_battler.screen_x - (@actor_command_window.width/2)
y_pos = @active_battler.screen_y
when 1
x_pos = @active_battler.screen_x - @actor_command_window.width - 16
y_pos = @active_battler.screen_y - @actor_command_window.height
when 2
x_pos = @active_battler.screen_x + 16
y_pos = @active_battler.screen_y - @actor_command_window.height
when 3
x_pos = @active_battler.screen_x - (@actor_command_window.width/2)
y_pos = @active_battler.screen_y - @actor_command_window.height - 48
end
@actor_command_window.x = x_pos >= 0 ? x_pos : 0
@actor_command_window.x = x_pos+@actor_command_window.width <= 640 ? x_pos : 640-@actor_command_window.width
@actor_command_window.y = y_pos >= 0 ? y_pos : 0
@actor_command_window.y = y_pos+@actor_command_window.height <= 480 ? y_pos : 480-@actor_command_window.height
# ??????????????????
@actor_command_window.z = 9999
end
end
#--------------------------------------------------------------------------
# ? Events Move
#--------------------------------------------------------------------------
alias update_phase4_step3_sdva update_phase4_step3
def update_phase4_step3
if SDVA::ATTACK_MOVE
if @active_battler.current_action.basic == 0
@active_battler.current_action.move_action = true
end
end
if SDVA::SKILL_MOVE
if @active_battler.current_action.kind == 1
@active_battler.current_action.move_action = true
end
end
if SDVA::ITEM_MOVE
if @active_battler.current_action.kind == 2
@active_battler.current_action.move_action = true
end
end
# ??????????????????????
if @active_battler.is_a?(Game_Actor) and
@active_battler.current_action.move_action
# ?????
if @active_battler.moving == 2
update_phase4_step3_sdva
end
elsif @active_battler.moving == 0
update_phase4_step3_sdva
end
end
#--------------------------------------------------------------------------
# ? Enemies Phase
#--------------------------------------------------------------------------
alias update_phase4_step6_sdva update_phase4_step6
def update_phase4_step6
@active_battler.current_action.move_action = false
@active_battler.move_reset
update_phase4_step6_sdva
end
end

#==============================================================================
# ? Spriteset_Battle
#==============================================================================

class Spriteset_Battle
#--------------------------------------------------------------------------
# ? ?????????
#--------------------------------------------------------------------------
alias initialize_sdva initialize
def initialize
initialize_sdva
@viewport2.z = 1
end
end

#==============================================================================
# ? Arrow_Actor
#==============================================================================

class Arrow_Actor < Arrow_Base
#--------------------------------------------------------------------------
# ? Update
#--------------------------------------------------------------------------
alias update_sdva update
def update
update_sdva
# ?????
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
end
end

#==============================================================================
# ? Arrow_Enemy
#==============================================================================

class Arrow_Enemy < Arrow_Base
#--------------------------------------------------------------------------
# ? Enemy Cursor
#--------------------------------------------------------------------------
alias update_sdva update
def update
update_sdva
# Change Choice
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
# Change Choice #2
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
end
end
#--------------------------------------------------------------------------
# ? Damage Class (Written By Squall
#--------------------------------------------------------------------------

class RPG::Sprite < ::Sprite
 #--------------------------------------------------------------------------
 # ? Initialize
 #--------------------------------------------------------------------------
 def initialize(viewport = nil)
 super(viewport)
 @_whiten_duration = 0
 @_appear_duration = 0
 @_escape_duration = 0
 @_collapse_duration = 0
 @_damage_durations = []
 @_animation_duration = 0
 @_blink = false
 end
 #--------------------------------------------------------------------------
 # ? Dispose
 #--------------------------------------------------------------------------
 def dispose
 dispose_damage(0...@_damage_durations.size)
 dispose_animation
 dispose_loop_animation
 super
 end
 #--------------------------------------------------------------------------
 # ? Effect
 #--------------------------------------------------------------------------
 def effect?
 damage_duration = 0
 for value in @_damage_durations
 damage_duration += value
 end
 @_whiten_duration > 0 or
 @_appear_duration > 0 or
 @_escape_duration > 0 or
 @_collapse_duration > 0 or
 damage_duration > 0 or
 @_animation_duration > 0
 end
 #--------------------------------------------------------------------------
 # ? Damage
 #--------------------------------------------------------------------------
 def damage(value, critical)
 dispose_damage(0...@_damage_durations.size)
 @_damage_sprites = []
 if value.is_a?(Numeric)
 damage_string = value.abs.to_s
 else
 damage_string = value.to_s
 end
 if critical
 damage_string += " CRITICAL HIT"
 end
 
 for i in 0...damage_string.size
 letter = damage_string[i..i]
 bitmap = Bitmap.new(48, 48)
 bitmap.font.size = 24
 bitmap.font.color.set(0, 0, 0)
 bitmap.draw_text(-1, 12-1, 48, 48, letter, 1)
 bitmap.draw_text(+1, 12-1, 48, 48, letter, 1)
 bitmap.draw_text(-1, 12+1, 48, 48, letter, 1)
 bitmap.draw_text(+1, 12+1, 48, 48, letter, 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, 48, 48, letter, 1)
 
 @_damage_sprites[i] = ::Sprite.new(self.viewport)
 @_damage_sprites[i].bitmap = bitmap
 @_damage_sprites[i].visible = false
 @_damage_sprites[i].ox = 16
 @_damage_sprites[i].oy = 16
 @_damage_sprites[i].x = self.x - self.ox / 2 + i * 12
 @_damage_sprites[i].y = self.y - self.oy / 2
 @_damage_sprites[i].z = 3000
 @_damage_durations[i] = 40 + i * 2
 end
 end
 #--------------------------------------------------------------------------
 # ? Dispose Damage
 #--------------------------------------------------------------------------
 def dispose_damage(index)
 return if @_damage_sprites == nil
 if @_damage_sprites[index].is_a?(::Sprite) and @_damage_sprites[index].bitmap != nil
 @_damage_sprites[index].bitmap.dispose
 @_damage_sprites[index].dispose
 @_damage_durations[index] = 0
 end
 end
 #--------------------------------------------------------------------------
 # ? Update
 #--------------------------------------------------------------------------
 def update
 super
 if @_whiten_duration > 0
 @_whiten_duration -= 1
 self.color.alpha = 128 - (16 - @_whiten_duration) * 10
 end
 if @_appear_duration > 0
 @_appear_duration -= 1
 self.opacity = (16 - @_appear_duration) * 16
 end
 if @_escape_duration > 0
 @_escape_duration -= 1
 self.opacity = 256 - (32 - @_escape_duration) * 10
 end
 if @_collapse_duration > 0
 @_collapse_duration -= 1
 self.opacity = 256 - (48 - @_collapse_duration) * 6
 end
 for i in 0...@_damage_durations.size
 damage_sprite = @_damage_sprites[i]
 next if @_damage_durations[i] == nil
 if @_damage_durations[i] > 0
 @_damage_durations[i] -= 1
 damage_sprite.visible = (@_damage_durations[i] <= 40)
 case @_damage_durations[i]
 when 38..39
 damage_sprite.y -= 4
 when 36..37
 damage_sprite.y -= 2
 when 34..35
 damage_sprite.y += 2
 when 28..33
 damage_sprite.y += 4
 end
 damage_sprite.opacity = 256 - (12 - @_damage_durations[i]) * 32
 if @_damage_durations[i] == 0
 dispose_damage(i)
 end
 end
 end
 if @_animation != nil and (Graphics.frame_count % 2 == 0)
 @_animation_duration -= 1
 update_animation
 end
 if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)
 update_loop_animation
 @_loop_animation_index += 1
 @_loop_animation_index %= @_loop_animation.frame_max
 end
 if @_blink
 @_blink_count = (@_blink_count + 1) % 32
 if @_blink_count < 16
 alpha = (16 - @_blink_count) * 6
 else
 alpha = (@_blink_count - 16) * 6
 end
 self.color.set(255, 255, 255, alpha)
 end
 @@_animations.clear
 end
end
#--------------------------------------------------------------------------
# ? Ends Damage Class (Written by Squall)
#--------------------------------------------------------------------------

#--------------------------------------------------------------------------
# ? CBS Menu System (By ParaDog)
#--------------------------------------------------------------------------
module PARA_CTB

# HP Color
HP_COLOR_LEFT = Color.new(0, 40, 0, 255)
# HP Color 2
HP_COLOR_RIGHT= Color.new(0, 150, 0, 255)
# SP Color
SP_COLOR_LEFT = Color.new(0, 0, 40, 255)
# SP Color 2
SP_COLOR_RIGHT= Color.new(0, 0, 150, 255)

#Frames Initialize
FRAME_COLOR = Color.new(192, 192, 192, 255)
# Frame Border size
FRAME_BORDER = 1
# Background Color
BACK_COLOR = Color.new(128, 128, 128, 128)

# Font Size
NAME_FONT_SIZE =17
# HP/SP Font size
HPSP_FONT_SIZE =18
# Enemies name Font
ENEMY_FONT_SIZE =16
# Draws the MAX HP of enemies
MAX_DRAW = false

#--------------------------------------------------------------------------------
# * Party Things
#--------------------------------------------------------------------------------

# Party Size (Default 4)
PARTY_SIZE = 4

# Enemy Group Naming
ENEMY_GROUPING = false

#Sets your opinion if you want
ENEMY_DRAWING_MATER = 0

# Draws Actor's HP / MP in help menu (Default : True)
HELP_DRAWING_MATER_ACTOR = true
# Draws Enemy's HP/MP in help menu (Default : False)
HELP_DRAWING_MATER_ENEMY = false

# Window Positioning Change
WINDOWPOS_CHANGE = false
WINDOWPOS_X = 100 # X??
WINDOWPOS_Y = 320 # Y??

# Sets Menu Opacity
WINDOW_OPACITY = 160

end

#--------------------------------------------------------------------------
# ? Ends The Variables
#--------------------------------------------------------------------------
#==============================================================================
# ? Scene_Battle
#==============================================================================

class Scene_Battle

#--------------------------------------------------------------------------
# ? CTB Main
#--------------------------------------------------------------------------
alias main_ctb main
def main
# Starts CTB Window
@status_window2 = Window_BattleStatus_enemy.new
main_ctb
# Dispose CTB Window
@status_window2.dispose
end
#--------------------------------------------------------------------------
# ? CTB Update
#--------------------------------------------------------------------------
alias ctb_update update
def update
# Interepter call
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_window2.refresh
end
end
end
ctb_update
end
#--------------------------------------------------------------------------
# ? Phases
#--------------------------------------------------------------------------
alias phase3_setup_command_window_ctb phase3_setup_command_window
def phase3_setup_command_window
@actor_command_window.back_opacity = PARA_CTB::WINDOW_OPACITY
phase3_setup_command_window_ctb
if PARA_CTB::WINDOWPOS_CHANGE
# ???????????????????
@actor_command_window.x = PARA_CTB::WINDOWPOS_X
@actor_command_window.y = PARA_CTB::WINDOWPOS_Y
# ??????????????????
@actor_command_window.z = 9999
end
end
#--------------------------------------------------------------------------
# ? Phases
#--------------------------------------------------------------------------
alias update_phase1_ctb update_phase1
def update_phase1
# ???????????
@status_window2.refresh
update_phase1_ctb
end
#--------------------------------------------------------------------------
# ? Phase six
#--------------------------------------------------------------------------
alias update_phase4_step6_ctb update_phase4_step6
def update_phase4_step6
# ???????????
@status_window2.refresh
update_phase4_step6_ctb
end
end

#==============================================================================
# ? Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# ? Initialize
#--------------------------------------------------------------------------
def initialize
super(160, 320, 480, 160)
self.contents = Bitmap.new(width - 32, height - 32)
@level_up_flags = []
for i in 0..$game_party.actors.size
@level_up_flags.push(false)
end
@before_hp = []
@before_sp = []
@before_states = []
@now_hp = []
@now_sp = []
@now_states = []
refresh
end
#--------------------------------------------------------------------------
# ? Refreshes The Party members
#--------------------------------------------------------------------------
def refresh
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
line_height = 120 / PARA_CTB::PARTY_SIZE
actor_y = i * line_height + 4
# ????????????
@now_hp[i] = actor.hp
@now_sp[i] = actor.sp
@now_states[i] = actor.states
# ??????
if @level_up_flags[i]
self.contents.fill_rect(344, actor_y, 100, 32, Color.new(0, 0, 0, 0))
self.contents.font.color = normal_color
self.contents.draw_text(344, actor_y, 120, 32, "LEVEL UP!")
end
end
# ??????????????
# ?????????????????????
if @before_hp == nil or @before_sp == nil or @before_states == nil or @before_hp != @now_hp or @before_sp != @now_sp or @before_states != @now_states
self.contents.clear
for i2 in 0...$game_party.actors.size
actor = $game_party.actors[i2]
line_height = 120 / PARA_CTB::PARTY_SIZE
actor_y = i2 * line_height + 4
self.contents.font.size = PARA_CTB::NAME_FONT_SIZE
# ?????
draw_actor_name(actor, 4, actor_y+16-PARA_CTB::NAME_FONT_SIZE)
# HP???
hp_color1 = PARA_CTB::HP_COLOR_LEFT
hp_color2 = PARA_CTB::HP_COLOR_RIGHT
draw_meter(actor.hp, actor.maxhp, 125, actor_y+14, 80, 8, hp_color1, hp_color2)
draw_actor_hp(actor, 102, actor_y+16-PARA_CTB::HPSP_FONT_SIZE, 100)
# SP???
sp_color1 = PARA_CTB::SP_COLOR_LEFT
sp_color2 = PARA_CTB::SP_COLOR_RIGHT
draw_meter(actor.sp, actor.maxsp, 245, actor_y+14, 80, 8, sp_color1, sp_color2)
draw_actor_sp(actor, 222, actor_y+16-PARA_CTB::HPSP_FONT_SIZE, 100)
# ?????????????
@before_hp[i2] = actor.hp
@before_sp[i2] = actor.sp
@before_states[i2] = actor.states
# ??????
if @level_up_flags[i2] == false
draw_actor_state(actor, 344, actor_y)
end
end
end

end
#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
def update
super
end
#--------------------------------------------------------------------------
# ? HP ???
# actor : ????
# x : ??? X ??
# y : ??? Y ??
# width : ?????
#--------------------------------------------------------------------------
def draw_actor_hp(actor, x, y, width = 144)
# ??? "HP" ???
self.contents.font.color = system_color
self.contents.font.size = 16
self.contents.draw_text(x, y+2, 32, 32, $data_system.words.hp)
self.contents.font.color = normal_color
self.contents.font.size = PARA_CTB::HPSP_FONT_SIZE
if PARA_CTB::MAX_DRAW
# MaxHP ???
self.contents.draw_text(x, y, width, 32, actor.maxhp.to_s, 2)
text_size = self.contents.text_size(actor.maxhp.to_s)
text_x = x + width - text_size.width - 12
self.contents.draw_text(text_x, y, 12, 32, "/", 1)
# HP ???
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
text_x = text_x - text_size.width
self.contents.draw_text(text_x, y, text_size.width, 32, actor.hp.to_s, 2)
else
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
self.contents.draw_text(x, y, width, 32, actor.hp.to_s, 2)
end
end
#--------------------------------------------------------------------------
# ? SP ???
# actor : ????
# x : ??? X ??
# y : ??? Y ??
# width : ?????
#--------------------------------------------------------------------------
def draw_actor_sp(actor, x, y, width = 144)
# ??? "SP" ???
self.contents.font.color = system_color
self.contents.font.size = 16
self.contents.draw_text(x, y+2, 32, 32, $data_system.words.sp)
self.contents.font.color = normal_color
self.contents.font.size = PARA_CTB::HPSP_FONT_SIZE
if PARA_CTB::MAX_DRAW
# MaxSP ???
self.contents.draw_text(x, y, width, 32, actor.maxsp.to_s, 2)
text_size = self.contents.text_size(actor.maxsp.to_s)
text_x = x + width - text_size.width - 12
self.contents.draw_text(text_x, y, 12, 32, "/", 1)
# SP ???
self.contents.font.color = actor.sp == 0 ? knockout_color :
actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
text_x = text_x - text_size.width
self.contents.draw_text(text_x, y, text_size.width, 32, actor.sp.to_s, 2)
else
self.contents.font.color = actor.sp == 0 ? knockout_color :
actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
self.contents.draw_text(x, y, width, 32, actor.sp.to_s, 2)
end
end
end

#==============================================================================
# ? ??????????????
#==============================================================================

class Window_BattleStatus_enemy < Window_Base
#--------------------------------------------------------------------------
# ? ?????????
#--------------------------------------------------------------------------
def initialize
super(0, 320, 160, 160)
self.contents = Bitmap.new(width - 32, height - 32)
refresh
end
#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = normal_color
self.contents.font.size = PARA_CTB::ENEMY_FONT_SIZE
@exist_enemies = []
if $game_troop.enemies != nil
if PARA_CTB::ENEMY_GROUPING
ememy_list = []
ememy_list_index = []
# ??????????
for i in 0...$game_troop.enemies.size
enemy = $game_troop.enemies[i]
if enemy.exist?
if ememy_list.include?(enemy.name)
ememy_list_index[ememy_list.index(enemy.name)] += 1
else
# ????????
ememy_list.push(enemy.name)
ememy_list_index[ememy_list.index(enemy.name)] = 1
end
end
end
# ????????????
enemy_index = 0
for enemy_name in ememy_list
enemy_y = enemy_index * (PARA_CTB::ENEMY_FONT_SIZE+6) + 4
if ememy_list_index[enemy_index] > 1
enemy_name = enemy_name + "?" + ememy_list_index[enemy_index].to_s
end
self.contents.draw_text(4, enemy_y, 160, 20, enemy_name)
enemy_index += 1
end
else
# ??????????
enemy_index = 0
for i in 0...$game_troop.enemies.size
enemy = $game_troop.enemies[i]
if enemy.exist?
@exist_enemies.push(enemy)
line_height = PARA_CTB::ENEMY_FONT_SIZE + 6
if PARA_CTB::ENEMY_DRAWING_MATER != 0
line_height += 10
end
enemy_y = enemy_index * line_height + 4
self.contents.draw_text(4, enemy_y, 160, 20, enemy.name)
enemy_index += 1
# HP??????
if PARA_CTB::ENEMY_DRAWING_MATER == 1
hp_color1 = PARA_CTB::HP_COLOR_LEFT
hp_color2 = PARA_CTB::HP_COLOR_RIGHT
y = enemy_y + PARA_CTB::ENEMY_FONT_SIZE + 3
draw_meter(enemy.hp, enemy.maxhp, 4, y, 80, 8, hp_color1, hp_color2)
end
end
end
end
end
end
end

#==============================================================================
# ? Window_Base
#==============================================================================

class Window_Base < Window

#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
def draw_meter(now, max, x, y, width, height, start_color, end_color=start_color )
self.contents.fill_rect(x, y, width, height, PARA_CTB::FRAME_COLOR)
self.contents.fill_rect(x+PARA_CTB::FRAME_BORDER, y+PARA_CTB::FRAME_BORDER, width-PARA_CTB::FRAME_BORDER*2, height-PARA_CTB::FRAME_BORDER*2, PARA_CTB::BACK_COLOR)
now = now > max ? max : now
percentage = max != 0 ? (width-2) * now / max.to_f : 0
if start_color == end_color
self.contents.fill_rect(x+1, y+1, percentage, height-2, start_color)
else
for i in 1..percentage
r = start_color.red + (end_color.red - start_color.red) / percentage * i
g = start_color.green + (end_color.green - start_color.green) / percentage * i
b = start_color.blue + (end_color.blue - start_color.blue) / percentage * i
a = start_color.alpha + (end_color.alpha - start_color.alpha) / percentage * i
self.contents.fill_rect(x+i, y+1, 1, height-2, Color.new(r, g, b, a))
end
end
end
end

#==============================================================================
# ? Window_Help
#==============================================================================

class Window_Help < Window_Base
#--------------------------------------------------------------------------
# ? ??????
# actor : ??????????????
#--------------------------------------------------------------------------
alias set_actor_ctb set_actor
def set_actor(actor)
if PARA_CTB::HELP_DRAWING_MATER_ACTOR
self.contents.clear
draw_actor_name(actor, 4, 0)
draw_actor_state(actor, 140, 0)
hp_color1 = PARA_CTB::HP_COLOR_LEFT
hp_color2 = PARA_CTB::HP_COLOR_RIGHT
draw_meter(actor.hp, actor.maxhp, 316, 18, 112, 8, hp_color1, hp_color2)
draw_actor_hp(actor, 284, 0)
sp_color1 = PARA_CTB::SP_COLOR_LEFT
sp_color2 = PARA_CTB::SP_COLOR_RIGHT
draw_meter(actor.sp, actor.maxsp, 492, 18, 112, 8, sp_color1, sp_color2)
draw_actor_sp(actor, 460, 0)
@actor = actor
@text = nil
self.visible = true
else
set_actor_ctb(actor)
end
end
#--------------------------------------------------------------------------
# ? ??????
# enemy : ????????????????
#--------------------------------------------------------------------------
alias set_enemy_ctb set_enemy
def set_enemy(enemy)
if PARA_CTB::HELP_DRAWING_MATER_ENEMY
self.contents.clear
draw_actor_name(enemy, 4, 0)
draw_actor_state(enemy, 140, 0)
hp_color1 = PARA_CTB::HP_COLOR_LEFT
hp_color2 = PARA_CTB::HP_COLOR_RIGHT
draw_meter(enemy.hp, enemy.maxhp, 316, 18, 112, 8, hp_color1, hp_color2)
draw_actor_hp(enemy, 284, 0)
sp_color1 = PARA_CTB::SP_COLOR_LEFT
sp_color2 = PARA_CTB::SP_COLOR_RIGHT
draw_meter(enemy.sp, enemy.maxsp, 492, 18, 112, 8, sp_color1, sp_color2)
draw_actor_sp(enemy, 460, 0)
self.visible = true
else
set_enemy_ctb(enemy)
end
end
end
#------------------------------------------------------------------------------
# ? End SDK Enable Test
#------------------------------------------------------------------------------
end

Above main, and below everything else and the SDK. Yes, SDK 1.5 is mandatory.

Copy and paste everything inside the box?
If you do something pops up that says something about a Syntax error.