Script Catterpillar

Autor: thiago_d_d

Código:

#==============================================================
# * MRM - Comunidade RPG Maker!
#  www.mundorpgmaker.com
# * GRM - Comunidade RPG Maker!
#  www.galaxiarpgmaker.com.br
#
# [TSDA] Catterpillar
#  --> Versão 1.3
# Última atualização: 11/12/2010
# ----Créditos
#    thiago_d_d - por fazer o script
#    Vash-X - pelo CHANGE GROUP MENU
#
#--------------------------------------------------------------
# * Características
#--------------------------------------------------------------
# + Adiciona um sistema de catterpillar.
# É um sistema em que um herói secundário segue o herói
# principal(pode ser útil quando há pets).
# Catterpillar vem do inglês e quer dizer centopeia,
# que representa a fila formada pelo herói principal e
# pelo secundário.Por exemplo,no  screenshot o de laranja
# é o herói principal,e o outro é o secundário que o segue!
# Legal!Além disso,bons catterpillares incluem outras coisas,
# como inventário,possibilidade de abandonar seu aliado,etc.
# Esse catterpillar é especial,pois é possível largar o aliado
# no mapa e mudar o líder do grupo no menuAinda por cima,
# depois de largar o aliado,é possível voltar para
# resgatá-lo. Teste por si mesmo, e veja como é legal!
#
#--------------------------------------------------------------
# * Instalação
#--------------------------------------------------------------
# Cole esse script acima de Main e configue as linhas abaixo.
#==============================================================
module TSDA
  #Usará o menu especial?
  CHANGE_GROUP_MENU = false
  #Poderá largar o aliado no mapa apertando A?
  STOP_ALLIES = false
end
class Game_Character
  alias old_passable? passable?
  #Determina se um tile é passável para movimento
  def passable?(x,y,d)
    #Não é o jogador
    if self != $game_player
      new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
      new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
      if @through
        return true
      end
      #Tem aliado na nova posição
      if $game_allies.have_allies_here(new_x,new_y)
        #Não é passável
        return false
      end
    #É o jogador
    else
      new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
      new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
      if @through
        return true
      end
      #Há aliados que não estão junto do herói
      if $game_allies.have_only_allies_here(new_x,new_y)
        return false
      end
    end
    old_passable?(x,y,d)
  end
end
#--------------------------------
#Guarda Informações de aliados parados
class Ally_Info
  attr_accessor :x
  attr_accessor :y
  attr_accessor :map_id
  attr_accessor :actor
end
#--------------------------------
class Game_Stopped_Ally < Game_Character
  def initialize(actor,x,y)
    super()
    @actor = actor
    moveto(x,y)
    refresh
  end
 
  #Atualiza gráficos do aliado
  def refresh
    #Sem aliado
    if @actor == nil
      #Limpar tonalidade e gráfico
      @character_name = ""
      @character_hue = 0
      #Terminou de atualizar
      return
    end
    #Inicializa gráficos com base no aliado
    @character_name = @actor.character_name
    @character_hue = @actor.character_hue
    # Inicializar a opacidade e a sinteticidade
    @opacity = 255
    @blend_type = 0
  end
 
  #Checa se vai ativar evento por toque
  def check_event_trigger_touch(x, y)
    #Nunca ativa
    return false
  end
end
#--------------------------------
class Game_Allies
  attr_reader  :stopped_allies  #Aliados que pararam
  attr_reader  :ally            #Aliado atual ,que está andando com o herói
 
  def initialize
    #Nenhum aliado parou
    @stopped_allies = []
    #Se a equipe tem mais de um integrante
    if $game_party.actors.size > 1
      #Segundo membro é o aliado
      @ally = Game_Ally.new($game_party.actors[1])
    #Senão
    else
      #Nenhum aliado
      @ally = Game_Ally.new(nil)
    end
  end
 
  def turned_to
    do_turn
    for i in @stopped_allies
      if i.map_id == $game_map.map_id
        if @t_x == i.x && @t_y == i.y
          @turned_actor = i.actor
          return true
        end
      end
    end
    return false
  end
 
  def do_turn
    case $game_player.direction
    when 2
      @t_x = $game_player.x
      @t_y = $game_player.y + 1
    when 4
      @t_x = $game_player.x - 1
      @t_y = $game_player.y
    when 6
      @t_x = $game_player.x + 1
      @t_y = $game_player.y
    when 8
      @t_x = $game_player.x
      @t_y = $game_player.y - 1
    end
  end
 
  def get_turned_actor
    return @turned_actor
  end
 
  def add_allies(actor)
    for i in @stopped_allies
      if i.actor == $game_actors[actor]
        @stopped_allies.delete(i)
        break
      end
    end
    if @ally.actor == nil
      if $game_party.actors.size > 1
        @ally.actor = $game_party.actors[1]
        @ally.refresh
        @ally.move_allyto($game_player.x,$game_player.y)
      end
    end
    if $scene.is_a?(Scene_Map)
      $scene.recreate_spriteset_map
    end
  end
 
  #Obtém sprites dos atores parados
  def get_sprites(viewport)
    sprites = []
    counter = 0
    for i in @stopped_allies
      if $game_map.map_id == i.map_id
        st_ally = Game_Stopped_Ally.new(i.actor,i.x,i.y)
        sprites[counter] = Sprite_Character.new(viewport,
        st_ally)
        st_ally.refresh
        counter += 1
      end
    end
    if sprites.size > 0
      return sprites
    end
    return nil
  end
 
  #Faz aliado atual parar
  def stop_ally
    if @ally.actor == nil || @ally.moving?
      return
    end
    #Aramazena informações do aliado que vai parar
    info = Ally_Info.new
    info.x = @ally.x
    info.y = @ally.y
    info.map_id = @ally.map_id
    info.actor = @ally.actor
    @stopped_allies[@stopped_allies.size] = info
    $game_party.remove_actor(info.actor.id)
    $scene.update_spriteset_map
  end
 
  #Tem qualquer aliado aqui?
  def have_allies_here(x,y)
    #Procura todos os aliados parados
    for i in @stopped_allies
      #Aliado está no mapa
      if i.map_id == $game_map.map_id
        #Aliado tem mesma posição do destino
        if i.x == x && i.y == y
          #Tem aliado aqui
          return true
        end
      end
    end
    #Aliado do herói é existente
    if @ally.actor != nil
      #Aliado tem mesma posição de destino
      if x == @ally.x && y == @ally.y
        #Tem aliado aqui
        return true
      end
    end
    #Não tem aliado aqui
    return false
  end
 
  #Tem algum aliado não principal aqui?
  def have_only_allies_here(x,y)
    #Procura todos os aliados parados
    for i in @stopped_allies
      #Aliado está no mapa
      if i.map_id == $game_map.map_id
        #Aliado tem mesma posição do destino
        if i.x == x && i.y == y
          #Tem aliado aqui
          return true
        end
      end
    end
    #Não tem aliado aqui
    return false
  end
end
#--------------------------------
class Game_Ally < Game_Character
  attr_accessor :actor
  attr_reader  :map_id
 
  def initialize(actor)
    super()
    #Aliado é o ator especificado
    @actor = actor
    @terminated_movement = false
    @player_is_near = false
    @map_id = 0
  end
 
  #Atualiza gráficos do aliado
  def refresh
    #Sem aliado
    if @actor == nil
      #Limpar tonalidade e gráfico
      @character_name = ""
      @character_hue = 0
      #Terminou de atualizar
      return
    end
    #Inicializa gráficos com base no aliado
    @character_name = @actor.character_name
    @character_hue = @actor.character_hue
    # Inicializar a opacidade e a sinteticidade
    @opacity = 255
    @blend_type = 0
  end
 
  #Teleporta aliado para perto do jogador
  def move_allyto(x,y)
    #Analisa em todas as direções perto do herói
    for i in [1,2,3,4]
      #Se direção for válida
      #Teleporta herói para ela
      if move_ally(x,y,i)
        #Jogador está perto
        @player_is_near
        @map_id = $game_map.map_id
        return
      end
    end
    #Nenhuma posição disponível
    #Desativa aliado
    @actor = nil
    @map_id = 0
    #Atualiza gráficos
    refresh
  end
 
  #Verifica se é valida a direção d para teleportar
  def move_ally(x,y,d)
    case d
    #Quando acima
    when 1
      #Valida se é possível teleportar acima
      return validate(x,y - 1)
    #Quando direita
    when 2
      #Valida se é possível teleportar a direita
      return validate(x + 1,y)
    #Quando abaixo
    when 3
      #Valida se é possível teleportar abaixo
      return validate(x,y + 1)
    #Quando esquerda
    when 4
      #Valida se é possível teleportar a esquerda
      return validate(x - 1,y)
    end
  end
 
  #Verifica se é possível teleportar aliado para a posição
  def validate(x,y)
    #É possível teleportá-lo para lá?
    if $game_map.valid?(x,y) && passable?(x,y,0) &&
      !$game_allies.have_allies_here(x,y)
      #Teleporta aliado
      for event in $game_map.events.values
        if event.x == x and event.y == y
          unless event.through
            return false
          end
        end
      end
      moveto(x,y)
      return true
    end
    #Posição não válida
    return false
  end
 
  def change_actor(actor)
    @actor = actor
    refresh
  end
 
  #Atualiza o aliado
  def update
    unless moving? or $game_system.map_interpreter.running? or
      @move_route_forcing or $game_temp.message_window_showing
      #Aliado terminou um movimento e está perto
      if @terminated_movement && @player_is_near
        @terminated_movement = false
        #Vira na direção do herói
        case @term_dir
        when 1
          turn_up
        when 2
          turn_right
        when 3
          turn_down
        when 4
          turn_left
        end
      end
    end
    super
  end
 
  #Jogador se mexendo para baixo:se move junto
  def player_moving_down
    #Virar para baixo quando acabar movimento
    @term_dir = 3
    #Se move
    move_up_down(-1)
  end
 
  #Jogador se mexendo para cima:se move junto
  def player_moving_up
    #Virar para cima quando acabar movimento
    @term_dir = 1
    #Se move
    move_up_down(1)
  end
 
  #Move aliado para cima ou para baixo
  def move_up_down(con)
    #Só se move se o herói estiver se movendo também
    if $game_player.moving?
      #Assume que movimento terminou
      @terminated_movement = true
      #Assume que o jogador está perto
      @player_is_near = true
      #Armazena coordenadas do herói
      x = $game_player.x
      y = $game_player.y
      #Analiza para qual das direções se mover
      #Para que se conserve a "centopeia"
      if @x == x - 1 && @y == y + (1 * con)
        move_right
        return
      end
      if @x == x && @y == y + (2 * con)
        if con == -1
          move_down
        else
          move_up
        end
        return
      end
      if @y == y && @x == x
        if con == -1
          move_up
        else
          move_down
        end
        return
      end
      if @y == y + (1 * con) && @x == x + 1
        move_left
        return
      end
    end
    #Jogador não está perto
    @player_is_near = false
    #Movimento não terminou,pois não sequer executou
    @terminated_movement = false
  end
 
  #Jogador se mexendo para esquerda:se move junto
  def player_moving_left
    #Virar para esquerda quando acabar movimento
    @term_dir = 4
    #Se move
    move_right_left(1)
  end
 
  #Jogador se mexendo para direita:se move junto
  def player_moving_right
    #Virar para direita quando acabar movimento
    @term_dir = 2
    #Se move
    move_right_left(-1)
  end
 
  #Move aliado para esquerda ou para direita
  def move_right_left(con)
    #Só se move se o herói estiver se movendo também
    if $game_player.moving?
      #Assume que movimento terminou
      @terminated_movement = true
      #Assume que o jogador está perto
      @player_is_near = true
      #Armazena coordenadas do herói
      x = $game_player.x
      y = $game_player.y
      #Analiza para qual das direções se mover
      #Para que se conserve a "centopeia"
      if @x == x + (1 * con) && @y == y + 1
        move_up
        return
      end
      if @x == x + (1 * con) && @y == y - 1
        move_down
        return
      end
      if @y == y && @x == x
        if con == -1
          move_left
        else
          move_right
        end
        return
      end
      if @y == y && @x == x + (2 * con)
        if con == -1
          move_right
        else
          move_left
        end
        return
      end
    end
    #Jogador não está perto
    @player_is_near = false
    #Movimento não terminou,pois não sequer executou
    @terminated_movement = false
  end
 
  #Checa se vai ativar evento por toque
  def check_event_trigger_touch(x, y)
    #Nunca ativa
    return false
  end
 
  #Determina se um tile é passável no movimento
  def passable?(x, y, d)
    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
    #Destino inválido
    unless $game_map.valid?(new_x, new_y)
      #Não passável
      return false
    end
    #Debug ON e CTRL pressionado
    if $DEBUG and Input.press?(Input::CTRL)
      #Passável
      return true
    end
    #Passabilidade ON
    if @through
      #Passável
      return true
    end
    #Tile é bloqueado
    unless $game_map.passable?(new_x, new_y, 10 - d, self)
      #Não passável
      return false
    end
    return true
  end
end
#--------------------------------
class Game_Player
  alias old_moveto moveto
  def moveto(x,y)
    old_moveto(x,y)
    #Se $game_allies inicializou
    if $game_allies != nil
      #Teletransporta aliado para perto do herói
      $game_allies.ally.move_allyto(x,y)
    end
  end
 
  alias old_update_jump update_jump
  def update_jump
    old_update_jump
    if @jump_count < 1
      $game_allies.ally.actor = nil
      $game_allies.ally.refresh
      if $game_party.actors.size > 1
        $game_allies.ally.actor = $game_party.actors[1]
        $game_allies.ally.refresh
        $game_allies.ally.move_allyto($game_player.x,$game_player.y)
      end
    end
  end
 
  alias old_move_down move_down
  def move_down
    old_move_down
    $game_allies.ally.player_moving_down
  end
 
  alias old_move_lower_left move_lower_left
  def move_lower_left
    old_move_lower_left
    $game_allies.ally.actor = nil
    $game_allies.ally.refresh
  end
 
  alias old_move_upper_left move_upper_left
  def move_upper_left
    old_move_upper_left
    $game_allies.ally.actor = nil
    $game_allies.ally.refresh
  end
 
  alias old_move_lower_right move_lower_right
  def move_lower_right
    old_move_lower_right
    $game_allies.ally.actor = nil
    $game_allies.ally.refresh
  end
 
  alias old_move_upper_right move_upper_right
  def move_upper_right
    old_move_upper_right
    $game_allies.ally.actor = nil
    $game_allies.ally.refresh
  end
 
  alias old_move_up move_up
  def move_up
    old_move_up
    $game_allies.ally.player_moving_up
  end
 
  alias old_move_left move_left
  def move_left
    old_move_left
    $game_allies.ally.player_moving_left
  end
 
  alias old_move_right move_right
  def move_right
    old_move_right
    $game_allies.ally.player_moving_right
  end
 
  alias old_jump jump
  def jump(x_plus, y_plus)
    old_jump(x_plus,y_plus)
    $game_allies.ally.actor = nil
    $game_allies.ally.refresh
  end
 
  alias old_update update
  def update
    old_update
    $game_allies.ally.update
  end
end
#--------------------------------
class Spriteset_Map
  alias old_initialize initialize
  def initialize
    old_initialize
    #Cria sprite do aliado
    @ally_sprite = Sprite_Character.new(@viewport1, $game_allies.ally)
    @allies_sprites = $game_allies.get_sprites(@viewport1)
    update
  end
 
  alias old_update update
  def update
    old_update
    #Se sprite do aliado foi inicializado
    if @ally_sprite != nil
      #Atualiza sprite do aliado
      @ally_sprite.update
    end
    if @allies_sprites != nil
      for i in @allies_sprites
        i.update
      end
    end
  end
 
  alias old_dispose dispose
  def dispose
    old_dispose
    #Se aliado já está sendo exibido
    if @ally_sprite != nil
      #Fecha sprite
      @ally_sprite.dispose
    end
    if @allies_sprites != nil
      for i in @allies_sprites
        i.dispose
      end
    end
  end
 
  def update_allies
    @allies_sprites = $game_allies.get_sprites(@viewport1)
  end
end
#--------------------------------
class Scene_Map
  def initialize
    #Aliados não foram inicializados,logo os inicializa
    #(Ocorre somente na criação de um novo jogo)
    if $new_game == true
      $game_allies = Game_Allies.new
      #Atualiza gráficos do aliado
      $game_allies.ally.refresh
      $new_game = false
    end
  end
 
  alias old_update update
  def update
    old_update
    if Input.trigger?(Input::X)
      if TSDA::STOP_ALLIES
        $game_allies.stop_ally
      end
    elsif Input.trigger?(Input::C)
      if $game_allies.turned_to
        $game_party.add_actor($game_allies.get_turned_actor.id)
      end
    end
  end
 
  def update_spriteset_map
    @spriteset.update_allies
  end
 
  def recreate_spriteset_map
    @spriteset.dispose
    @spriteset = Spriteset_Map.new
  end
end
#--------------------------------
class Scene_Title
  alias old_command_new_game command_new_game
  def command_new_game
    $new_game = true
    old_command_new_game
    #Teleporta aliado para perto do herói
    $game_allies.ally.move_allyto($data_system.start_x,
    $data_system.start_y)
  end
end
#--------------------------------
class Scene_Save
  alias old_write_save_data write_save_data
  def write_save_data(file)
    old_write_save_data(file)
    #Salva os aliados
    Marshal.dump($game_allies, file)
  end
end
#--------------------------------
class Scene_Load
  alias old_read_save_data read_save_data
  def read_save_data(file)
    old_read_save_data(file)
    #Carrega aliados
    $game_allies        = Marshal.load(file)
  end
 
  alias old_on_decision on_decision
  def on_decision(filename)
    old_on_decision(filename)
    #Atualiza o aliado que está junto do herói
    $game_allies.ally.refresh
  end
end
#--------------------------------
class Scene_Allies
  def main
    @spriteset = Spriteset_Map.new
    @status_window = Window_Status_Allies.new
    @status_window.x = 80
    @status_window.y = 0
    @status_window.back_opacity= 160
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar Frame
      update
      # Abortar loop se a tela foi alterada
      if $scene != self
        break
      end
    end
    @status_window.dispose
    @spriteset.dispose
  end
 
  def update
    @status_window.update
    @spriteset.update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Menu.new(6)
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      $scene = Scene_Ally_Status.new(@status_window.index)
    end
  end
end
#-----------------------------
class Scene_Ally_Status
 
  def initialize(index)
    @actor = $game_allies.stopped_allies[index]
    @actor_index = index
  end
 
  def main
    @spriteset = Spriteset_Map.new
    @status_window = Window_Status_Ally.new(@actor)
    Graphics.transition
    # Loop principal
    loop do
      # Aqui a tela é atualizada
      Graphics.update
      # E os dados também
      Input.update
      # Então os frames são atualizados
      update
      # Abortar loop se a janela for alterada
      if $scene != self
        break
      end
    end
    # preparar para transição
    Graphics.freeze
    @spriteset.dispose
    @status_window.dispose
  end
 
  def update
    @spriteset.update
    @status_window.update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Allies.new
      return
    end
    if Input.trigger?(Input::R)
      $game_system.se_play($data_system.cursor_se)
      @actor_index += 1
      @actor_index %= $game_allies.stopped_allies.size
      $scene = Scene_Ally_Status.new(@actor_index)
      return
    end
    if Input.trigger?(Input::L)
      $game_system.se_play($data_system.cursor_se)
      @actor_index += $game_allies.stopped_allies.size - 1
      @actor_index %= $game_allies.stopped_allies.size
      $scene = Scene_Ally_Status.new(@actor_index)
      return
    end
  end
end

#----------------------------
class Window_Status_Ally < Window_Base
  def initialize(actor)
    super(160, 0, 320, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    self.back_opacity = 160
    @actor = actor
    refresh
  end
 
  def refresh
    self.contents.clear
    map = load_data("Data/MapInfos.rxdata")[@actor.map_id]
    draw_actor_graphic(@actor.actor, 40, 112)
    draw_actor_name(@actor.actor, 4, 0)
    draw_actor_class(@actor.actor, 4 + 144, 0)
    draw_actor_level(@actor.actor, 96, 32)
    self.contents.draw_text(96, 64, self.contents.text_size(map.name).width, 32,
    map.name)
    draw_actor_hp(@actor.actor, 96, 112, 172)
    draw_actor_sp(@actor.actor, 96, 144, 172)
    draw_actor_parameter(@actor.actor, 96, 192, 0)
    draw_actor_parameter(@actor.actor, 96, 224, 1)
    draw_actor_parameter(@actor.actor, 96, 256, 2)
    draw_actor_parameter(@actor.actor, 96, 304, 3)
    draw_actor_parameter(@actor.actor, 96, 336, 4)
    draw_actor_parameter(@actor.actor, 96, 368, 5)
    draw_actor_parameter(@actor.actor, 96, 400, 6)
  end
end

#----------------------------
class Window_Status_Allies < Window_Selectable
  def initialize
  super(0, 0, 480, 480)
  self.contents = Bitmap.new(width - 32, 4 * 116 - 16)
  self.contents.font.name = $defaultfonttype = "Tahoma" #Fonte
  self.contents.font.size = $defaultfontsize = 22 #Tamanho da fonte
  refresh
  self.active = true
  self.index = 0
 end
 #--------------------------------------------------------------------------
 def top_row
  return self.oy / 116
 end
 #--------------------------------------------------------------------------
 def top_row=(row)
  if row < 0
    row = 0
  end
  if row > row_max - 1
    row = row_max - 1
  end
  self.oy = row * 116
 end
 #--------------------------------------------------------------------------
 def update_cursor_rect
  if @index < 0
    self.cursor_rect.empty
    return
  end
  row = @index / @column_max
  if row < self.top_row
    self.top_row = row
  end
  if row > self.top_row + (self.page_row_max - 1)
    self.top_row = row - (self.page_row_max - 1)
  end
  cursor_width = self.width / @column_max - 32
  x = @index % @column_max * (cursor_width + 32)
  y = @index / @column_max * 116 - self.oy
  self.cursor_rect.set(x, y, cursor_width, 96)
 end
 def page_row_max
  return 4
 end
 def refresh
    self.contents.clear
    self.contents = Bitmap.new(width - 32, $game_allies.stopped_allies.size *
    116 - 16)
    @item_max = $game_allies.stopped_allies.size
    counter = 0
    for i in $game_allies.stopped_allies
      x = 64
      y = counter * 116
      actor = i.actor
      draw_actor_graphic(actor, x - 40, y + 80)
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 144, y)
      draw_actor_level(actor, x, y + 32)
      draw_actor_state(actor, x + 90, y + 32)
      draw_actor_exp(actor, x, y + 64)
      draw_actor_hp(actor, x + 236, y + 32)
      draw_actor_sp(actor, x + 236, y + 64)
      counter += 1
    end
  end
end

if TSDA::CHANGE_GROUP_MENU
  #===============================================================================
  # CHANGE GROUP MENU
  # Criado por Vash-X
  #===============================================================================
  class Game_Party
  #--------------------------------------------------------------------------
  def add_actor(actor_id)
    actor = $game_actors[actor_id]
      #Aqui define o número máximo do grupo
    if not @actors.include?(actor)
      @actors.push(actor)
      $game_player.refresh
    end
  end
  end
 
  class Game_Party
    alias old_add_actor add_actor
    def add_actor(actor)
      old_add_actor(actor)
      $game_allies.add_allies(actor)
    end
    alias old_remove_actor remove_actor
    def remove_actor(actor)
      old_remove_actor(actor)
      $game_allies.ally.actor = nil
      $game_allies.ally.refresh
      if $game_party.actors.size > 1
        $game_allies.ally.actor = $game_party.actors[1]
        $game_allies.ally.refresh
        $game_allies.ally.move_allyto($game_player.x,$game_player.y)
      end
    end
  end
  class Scene_Battle
  BATTLE_ACTOR_LIMIT = 4 #Aqui define a quantidade de heróis na bataha
                       
  alias stack_party_main main
 
  def main
    @map_party = []
    if $game_party.actors.size > BATTLE_ACTOR_LIMIT && BATTLE_ACTOR_LIMIT > 0
      for i in BATTLE_ACTOR_LIMIT ... $game_party.actors.size
        @map_party.push( $game_party.actors[i].id )
      end
      for i in @map_party
        $game_party.remove_actor(i)
      end
    end
    stack_party_main
  end
 
  alias stack_party_battle_end battle_end
 
  def battle_end(result)
    ret = stack_party_battle_end(result)
    for i in @map_party
      $game_party.add_actor(i)
    end
    return ret
  end
  end
 
  class Window_MenuStatus
  def initialize
    super(0, 0, 480, 480)
    self.contents = Bitmap.new(width - 32, $game_party.actors.size * 116 - 16)
    self.contents.font.name = $defaultfonttype = "Tahoma" #Fonte
    self.contents.font.size = $defaultfontsize = 22 #Tamanho da fonte
    refresh
    self.active = false
    self.index = -1
  end
  #--------------------------------------------------------------------------
  def top_row
    return self.oy / 116
  end
  #--------------------------------------------------------------------------
  def top_row=(row)
    if row < 0
      row = 0
    end
    if row > row_max - 1
      row = row_max - 1
    end
    self.oy = row * 116
  end
  #--------------------------------------------------------------------------
  def update_cursor_rect
    if @index < 0
      self.cursor_rect.empty
      return
    end
    row = @index / @column_max
    if row < self.top_row
      self.top_row = row
    end
    if row > self.top_row + (self.page_row_max - 1)
      self.top_row = row - (self.page_row_max - 1)
    end
    cursor_width = self.width / @column_max - 32
    x = @index % @column_max * (cursor_width + 32)
    y = @index / @column_max * 116 - self.oy
    self.cursor_rect.set(x, y, cursor_width, 96)
  end
  def page_row_max
    return 4
  end
  end
  class Scene_Menu
  # --------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
    @changer = 0
    @where = 0
    @checker = 0
  end
  # --------------------------------
  def main
    @spriteset = Spriteset_Map.new
    s1 = $data_system.words.item
    s2 = $data_system.words.skill
    s3 = $data_system.words.equip#Poderá mudar os nomes das janelas do menu
    s4 = "Status"             
    s5 = "Ordem"               
    s6 = "Salvar"
    s7 = "Aliados"
    s8 = "Sair"             
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6, s7,s8])
    @command_window.index = @menu_index
    @command_window.back_opacity= 160 #Muda a opacidade do menu
    if $game_party.actors.size == 0
      @command_window.disable_item(0)
      @command_window.disable_item(1)
      @command_window.disable_item(2)
      @command_window.disable_item(3)
    end
    if $game_allies.stopped_allies.size < 1
      @command_window.disable_item(6)
    end
    if $game_system.save_disabled
      @command_window.disable_item(5)
    end
    @playtime_window = Window_PlayTime.new
    @playtime_window.x = 0
    @playtime_window.y = 288
    @playtime_window.back_opacity= 160 #Muda a opacidade da janela de Tempo
    @gold_window = Window_Gold.new
    @gold_window.x = 0
    @gold_window.y = 416
    @gold_window.back_opacity= 160 #Muda a opacidade da janela de dinheiro
    @status_window = Window_MenuStatus.new
    @status_window.x = 160
    @status_window.y = 0
    @status_window.back_opacity= 160 #Muda a opacidade janela de status
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @command_window.dispose
    @playtime_window.dispose
    @gold_window.dispose
    @status_window.dispose
    @spriteset.dispose
  end
  # --------------------------------
  def update
    if $game_allies.stopped_allies.size < 1
      @command_window.disable_item(6)
    end
    @command_window.update
    @playtime_window.update
    @gold_window.update
    @status_window.update
    @spriteset.update
    if @command_window.active
      update_command
      return
    end
    if @status_window.active
      update_status
      return
    end
  end
  # --------------------------------
  def update_command
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
      return
    end
    if Input.trigger?(Input::C)
      if $game_party.actors.size == 0 and @command_window.index < 4
        $game_system.se_play($data_system.buzzer_se)
        return
      end
     
      case @command_window.index
      when 0
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Item.new
      when 1
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 2
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 3
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 4
        $game_system.se_play($data_system.decision_se)
        @checker = 0
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
 
      when 5
        if $game_system.save_disabled
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Save.new
      when 6
        if $game_allies.stopped_allies.size < 1
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Allies.new
      when 7
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_End.new
      end
      return
    end
  end
  # --------------------------------
  def update_status
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    if Input.trigger?(Input::C)
      case @command_window.index
      when 1
        if $game_party.actors[@status_window.index].restriction >= 2
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Skill.new(@status_window.index)
      when 2
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Equip.new(@status_window.index)
      when 3
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Status.new(@status_window.index)
      when 4
        $game_system.se_play($data_system.decision_se)
        if @checker == 0
          @changer = $game_party.actors[@status_window.index]
          @where = @status_window.index
          @checker = 1
        else
          $game_party.actors[@where] = $game_party.actors[@status_window.index]
          $game_party.actors[@status_window.index] = @changer
          @checker = 0
          @status_window.refresh
          $game_player.refresh
          $game_allies.ally.change_actor($game_party.actors[1])
        end
      end
      return
    end
  end
  end
end


Demo e Imagens
Não há necessidade de Demo. Screens:

Créditos
thiago_d_d por fazer o script
vash-x pelo menu
E a min por estar disponibilizando

o meu ta dando erro

linha 636

Você reviveu o tópico e ainda fez double post '

Se liga nisso cara...