Aldeia RPG

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Suporte no desenvolvimento de jogos


3 participantes

    Script Catterpillar

    matheus180
    matheus180
    Desenvolvedor
    Desenvolvedor

    Mensagens : 749
    Créditos : 174

    Script Catterpillar Empty Script Catterpillar

    Mensagem por matheus180 Ter Maio 17, 2011 1:52 pm

    Autor: thiago_d_d



    Script
    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:
    Script Catterpillar Aliados3
    Script Catterpillar Aliados2
    Script Catterpillar Aliados1

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


    _________________
    Script Catterpillar 3trEP
    Mateus Silva
    Mateus Silva
    Semi-Experiente
    Semi-Experiente

    Mensagens : 115
    Créditos : 4

    Script Catterpillar Empty Re: Script Catterpillar

    Mensagem por Mateus Silva Qui Fev 09, 2012 8:46 pm

    o meu ta dando erro
    Mateus Silva
    Mateus Silva
    Semi-Experiente
    Semi-Experiente

    Mensagens : 115
    Créditos : 4

    Script Catterpillar Empty Re: Script Catterpillar

    Mensagem por Mateus Silva Qui Fev 09, 2012 8:47 pm

    linha 636
    JuanCollin
    JuanCollin
    Membro de Honra
    Membro de Honra

    Mensagens : 977
    Créditos : 94

    Script Catterpillar Empty Re: Script Catterpillar

    Mensagem por JuanCollin Qui Fev 09, 2012 8:51 pm

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

    Se liga nisso cara...

    Conteúdo patrocinado

    Script Catterpillar Empty Re: Script Catterpillar

    Mensagem por Conteúdo patrocinado


      Data/hora atual: Seg Out 25, 2021 1:12 pm