O TEMA DO FÓRUM ESTÁ EM MANUTENÇÃO. FEEDBACKS AQUI: ACESSAR

[TSDA] Catterpillar

Iniciado por thiago_d_d, 30/11/2012 às 18:44

30/11/2012 às 18:44 Última edição: 20/01/2017 às 10:03 por King Gerar
Catterpillar


[info float=left border=#6587E4]
Informações:
--------------------------------------------------
.
• Autor: thiago_d_d
• Versão: 1.3
• Incompatibilidade: Média
• Lag gerado: Desprezível
• Customizável: Sim
• Requer Recursos Extras: Não
[/info][box class=catbg2]
Resumo
[/box][box class=catbg4]Pois então pessoal, por entrar nessa nova comunidade eu decidi repostar, aqui, os meus melhores scripts públicos (apenas os melhores). Espero que aproveitem este antigo script!
O script implementa um sistema de catterpillar, no qual os personagens da equipe seguem o herói principal. Não é um sistema de catterpillar comum. Ele possibilita a adição de infinitos membros na equipe, possibilita a mudança do herói principal, possibilita a soltura de heróis secundários, dentre outro. Tudo isso é configurável, ou seja, você poderá escolher entre usar ou não.[/box]


[box class=catbg2]
Instalação e configuração
[/box]
Cole o seguinte script acima de Main. Não esqueça de ler as instruções:
#==============================================================
# * 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



[box class=catbg2]
Demo e Imagens
[/box]
Não há necessidade de Demo. Screens:




[box class=catbg2]
Créditos
[/box]

  • thiago_d_d por fazer o script
  • vash-x pelo menu

Acho que você mesmo falou que foi um dos grandes scripts que você fez assim nos primordios :P, e concordo, catterpillar é uma função fueda, e essa equipe eu já vi algo do Deen também x]

Obrigado por trazer os seus scripts para cá, meu desejo é rechear a comunidade com conteúdo e espero que com todo mundo ajudando dê certo isso, boa sorte thiago, espero muito pelo seus próximos scripts, principalmente o de plataforma do Mario :D

Gostei do sistema cara, bem completo. Não vejo problemas nele, o menu lembra bastante o do ace e tira a maldita opção número de passos do xp u_u
Obrigado por postar.
To Die Is To Find Out If Humanity Ever Conquers Death

@Raizen
Nem é tão fueda assim, o fueda é que foi um script que eu fiz quando era mais nubinho. Hoje eu faria um sistema desses de novo com mais facilidade e com mais perfeição, é claro.  :hmm:
@B.loder
Que bom que gostou u.u
Eu pessoalmente não gosto do menu, provavelmente eu não usaria. Mas, infelizmente, ele é necessária para que a opção de soltar personagens esteja disponível. A não ser que o scripter do outro menu adicione uma opção que faça, o que particularmente não é difícil. Obrigado por comentar.

Que bom que começou a postar seus Scripts aqui.
Bom falando sobre o script,gostei bastante do script,vou testar aqui.

O menu não ficou bonito, verdade, mas para ficar melhor que o do xp acho que seria só aumentar a opacidade do fundo.
To Die Is To Find Out If Humanity Ever Conquers Death

Ficou ótimo, Thi!
Meus parabéns, espero ver mais dos seus scripts aqui!  :blink:

Boa Noite a todos!

Você poderia adaptar para o Netplay Master 4.9.2?

Abraços!!!
Script muito tttoooopppppppppppp