Forums » RGSS

Simples Mini Mapa + Lógica - Parte 1

    • 683 posts
    4 de junho de 2015 12h44min51s ART

    Introdução:

        Olá criaturas, eu estive dando alguns tutoriais sobre o desenvolvimento básico de ABS (Action Battle System), eu acho que é assim. Em fim, estou aqui para dar um pouco do meu conhecimento voltado para um desenvolvimento básico de um minimapa, sabe..?, aquela janelinha que mostra as posições passáveis e não passáveis, com lugares e direções, e um pouco de lógica, que foi oque eu não consegui dar no meus tutoriais sobre o sistema de batalha. Ok! Let's Go! XD.

    Sobre a lógica de uma Mini Mapa:

      Alguns Makers Novatos ou até Intermediários da área de programação em RGSS1/2, ficam se perguntando: "Como seria a desenvolvimento de um mini mapa? Será que tem que criar um segundo Spriteset_Map? Ou melhor, um segundo jogo paralelo?", oque na verdade, um mini mapa nu é nada mais do que um Viewport e um conjunto de imagens (Sprites) posicionados inteligentemente, que obedecem um padrão de acordo com a movimentação/posição do objeto em Display, se você não entendeu, vou começar a explicar melhor na parte de desenvolvimento.

    Iniciando:

      Antes de iniciar, peço que baixe agora o pack de gráficos com as imagens que iremos trabalhar no script. E depois de baixar, dentro da pasta Graphics, extraia-o, e assim podemos continuar sem bugs.

      link do pack: http://www.mediafire...5joiutxi5bi87uw

      Bem, no Rpg Maker XP (Que é o caso agora), crie um novo projeto com o nome de "Mini Mapa", se você criou, ele vai logicamente iniciar com um mapa que só tem grama e a posição do personagem, para começar, faça um lago, só agua, sem decoração, para facilitar, não meixa na largura e na altura do mapa, o meu mapa ficou assim:

    Imagem Postada

      Depois do mapa, abra o editor de scripts e crie um novo script chamado de "Mini Mapa", o nome vai ser simples, só para mantes organizado o nosso tutorial, dentro do mesmo, declare uma classe, o nome vai ser Mini_Mapa, assim:

    classMini_Mapa     def initialize   end     def update   end     def dispose   end   end


      Você viu que essa classe ela tem os métodos initialize (Padrão em todas as classes), update (para poder fazer a atualização do objeto(s) que estão incluídos ali, mas esse método não é padrão) e dispose(não padrão em classes não afiliadas da Sprite ou Bitmap, mas como ela vai ser tipo um imagem, precisamos usá-lo, para ficar mais fácil de trabalhar); Depois que ter digitado ou copiado e colado o código dentro do script cujo o qual pedi para criar, vamos criar constantes para personalizarmos a posição do display, abaixo da linha:

    classMini_Mapa


      Pule um linha, e abaixo um do outro ponha:

      X =10   Y =10


      Essas constantes irão servir para posicionar o display do Mini Mapa, caso você queira ela em tal posição da tela, basta trocar o valor do X ou do Y até chegar a ponto que você quer, serve mais ou menos como uma configuração. Depois disso o script deve ficar assim:

    classMini_Mapa     X =10   Y =10     def initialize   end     def update   end     def dispose   end   end


        Cheque se o script está assim, depois disso, vamos criar os Objetos importantes para a estrutura da janela, como Viewport (Se caso você não entenda desse objeto/classe é recomendado que olhasse a bíblia do rgss que lá explica bem sobre o mesmo) e Algumas Sprites, que caso é simples imagens, que você já deve saber utilizar se não, faça a minha recomendação com a classe anterior. Vamos ao initialize do script declarar dois objetos, a barra de suporte, cuja a mesma cerca o mini mapa, e o Viewport que sua posição, vai ser de acordo com as duas constantes que declaramos, o initialize tem que obedecer á isso:

      def initialize     @view=Viewport.new(X,Y,100,100)     @view.z =10     @sub=Sprite.new     @sub.bitmap = RPG::Cache.picture("sub_info")     @sub.x = X -5     @sub.y = Y -5     @pass=[]end


      Veja que criamos um Viewport (Ponto de Visão), onde seus primeiros argumentos de declaração são: X e Y, pois a declaração de um Viewport seria:

    viewport =Viewport.new(x,y,largura,altura)


      E tabe, criamos uma sprite que digitalmente se chama @sub, sendo que sua bitmap é uma imagem que disponibilizei dentro do pack, e sua posição x e y obedece a constante X e Y. Simples não? E uma Array que vai conter todas as imagens que vão ser atualizadas e posicionas inteligentemente no Viewport.

      Agora vamos trabalhar com a parte mais ou menos complicada, que é a que o script vai desenhar no mapa a posição não passáveis no mapa. Dentro do script crie um método para desenhar as posições passáveis e ignorar o não passável, o método vai se chamar draw, nome simples, assim:

    def draw     for x in0...$game_map.width       for y in0...$game_map.height         nextifnot $game_map.passable?(x,y,0)         pass=Sprite.new(@view)         pass.bitmap = RPG::Cache.picture("np_info")         pass.x = x *5         pass.y = y *5         @pass.push(pass)       end     endend



      Se você já sabe usar o método for X in Y ou for X in n...Y, já sabe que onde tem 

    for x in0...$game_map.width


      Vai testar todos os numeros entre 0 e a largura do mapa e logo em baixo também tem:

    for y in0...$game_map.height


      Que também vai testar todos os números entre 0 e a altura do mapa, mas porque um dentro do outro? Simples, se você observar um pouco abaixo vai ver:

    nextifnot $game_map.passable?(x,y,0)


      Ele apenas vai querer saber as posição passáveis do mapa, ou seja, next (próximo x ou y se aqui não for passável), e dai você também vê:

    pass=Sprite.new(@view)pass.bitmap = RPG::Cache.picture("np_info")pass.x = x *5pass.y = y *5@pass.push(pass)


      Que vai criando um Sprite encaixada dentro do @view (Viewport) que declaramos no initialize, e o mais interessante que as imagens vão sendo posicionadas de acordo com as posições passáveis do mapa, só que menor, e elas estão sendo armazenadas dentro da array @pass, que vai cuidar delas em breve;

      Bem, depois de ter analisado o que expliquei, ponha esse método dentro do script, sendo que ele vai ficar assim:

    classMini_Mapa     X =10   Y =10     def initialize     @view=Viewport.new(X,Y,100,100)     @view.z =10     @sub=Sprite.new     @sub.bitmap = RPG::Cache.picture("sub_info")     @sub.x = X -5     @sub.y = Y -5     @pass=[]     draw   end     def draw     for x in0...$game_map.width       for y in0...$game_map.height         nextifnot $game_map.passable?(x,y,0)         pass=Sprite.new(@view)         pass.bitmap = RPG::Cache.picture("np_info")         pass.x = x *5         pass.y = y *5         @pass.push(pass)       end     end   end     def update   end     def dispose   end   end

      

      Agora vamos fazer com que na hora que agente chamar a classe, ela possa desenhar as posições passáveis e não passáveis, para isso, ponha no final do initialize o método draw, que o nome do mesmo:

    def initialize     @view=Viewport.new(X,Y,100,100)     @view.z =10     @sub=Sprite.new     @sub.bitmap = RPG::Cache.picture("sub_info")     @sub.x = X -5     @sub.y = Y -5     @pass=[]     draw   end


      Agora chega de baboseira e vamos fazer o primeiro teste, no mapa atual crie um evento com um gráfico qualquer, com um comando de chamar script declarando a nossa janela com um variável global, dentro do comando chame assim:

    $mini_mapa =Mini_Mapa.new


    Inicie o jogo e você vê, agora se você fez tudo certo, vai estar assim, pelo menos no meu:

    Imagem Postada


    Veja que ele desenhou os bloquinhos de acordo com a posição passável no mapa. Simples não? Para ficar uma coisa mais legal, vamos fazer agora a movimentação do jogador, que será um pouco mais fácil.

    Crie um método que vai desenhar o player, chamado de draw_player, assim:

    def draw_player     @player=Sprite.new(@view)     @player.bitmap = RPG::Cache.picture("p_info")     @player.x = $game_player.x *5     @player.y = $game_player.y *5     @player.z =10   end


      Veja que ele apenas cria uma imagem de variável @player, aonde ela também vai está encaixada dentro do @view e seu posicionamento x e y obedece a uma métrica que é "uma posição vezes 5", e depois chame o método no final do initialize.

      Depois disso o script logicamente vai ficar assim:

    classMini_Mapa     X =10   Y =10     def initialize     @view=Viewport.new(X,Y,100,100)     @view.z =10     @sub=Sprite.new     @sub.bitmap = RPG::Cache.picture("sub_info")     @sub.x = X -5     @sub.y = Y -5     @pass=[]     draw     draw_player   end     def draw     for x in0...$game_map.width       for y in0...$game_map.height         nextifnot $game_map.passable?(x,y,0)         pass=Sprite.new(@view)         pass.bitmap = RPG::Cache.picture("np_info")         pass.x = x *5         pass.y = y *5         @pass.push(pass)       end     end   end     def draw_player     @player=Sprite.new(@view)     @player.bitmap = RPG::Cache.picture("p_info")     @player.x = $game_player.x *5     @player.y = $game_player.y *5     @player.z =10   end     def update   end     def dispose   end   end

      

    Trabalhando com as atualizações:

    Posicionamento do jogador:


    Vamos cuidar do método update, cujo o mesmo vai atualizar a posição do jogador sem fazer tipo um re-draw, ou chamar o método draw_player de novo, vamos criar um método chamado de update_player, antes de eu cita-lo, se você lembrar do método draw_player, vai ver:

    @player.x = $game_player.x *5     @player.y = $game_player.y *5


      Pois o método num é nada mais do que isso:

    def update_player     @player.ox = $game_map.display_x /26     @player.oy = $game_map.display_y /26     @player.x = $game_player.x *5     @player.y = $game_player.y *5   end


      Que seu trabalho, num é nada mais do que redeclarar a posição x e y, e de acordo com a posição x e y do jogador também, depois disso, execute o método update_player dentro o update da classe atuál e vamos fazer a estrutura do mini_mapa trabalhar, apenas debaixo de todo o script, redeclare a classe Scene_Map com um alias para o update atualizando o mini mapa se ele não for inexistente:

    classScene_Map     alias upo_up update     def update     upo_up     $mini_mapa.update unless $mini_mapa.nil?   end   end


      E o script no todo tem que ficar assim:

    classMini_Mapa     X =10   Y =10     def initialize     @view=Viewport.new(X,Y,100,100)     @view.z =10     @sub=Sprite.new     @sub.bitmap = RPG::Cache.picture("sub_info")     @sub.x = X -5     @sub.y = Y -5     @pass=[]     draw     draw_player   end     def draw     for x in0...$game_map.width       for y in0...$game_map.height         nextifnot $game_map.passable?(x,y,0)         pass=Sprite.new(@view)         pass.bitmap = RPG::Cache.picture("np_info")         pass.x = x *5         pass.y = y *5         @pass.push(pass)       end     end   end     def draw_player     @player=Sprite.new(@view)     @player.bitmap = RPG::Cache.picture("p_info")     @player.x = $game_player.x *5     @player.y = $game_player.y *5     @player.z =10   end     def update     update_player   end     def update_player     @player.ox = $game_map.display_x /26     @player.oy = $game_map.display_y /26     @player.x = $game_player.x *5     @player.y = $game_player.y *5   end     def dispose   end   end


      Agora inicie o jogo (Lembrando que no evento, no comando chamar script, nome da variável que vai conter o valor do mini mapa tem que ser "$mini_mapa"),  e pode andar livre e a posição do Sprite que representa o jogador vai sendo atualizado de acordo com a posição do $game_player.

      Depois disso ... A aulas por enquanto acaba aqui, mas continua na próxima parte...

    POR FAVOR, SE VOCÊ NÃO ESTIVER CONSEGUINDO TERMINAR O TUTORIAL, POSTE A SUA DUVIDA, ERRO, OU BUG, PARA QUE EU POSSA RESOLVER, PODERIA TER SIDO ERRO DE DIGITAÇÃO OU CONDUTA,SÓ ASSIM PODEREI AJUDAR VOCÊ, E AO MESMO TEMPO OS OUTROS MEMBROS, OBRIGADO.