Forums » RGSS

[Intermediário] O sistema de movimentação

    • 683 posts
    4 de junho de 2015 12h48min25s ART

    Aula Intermediária 1: O sistema de movimentação

     

    Posted Image
    www.mundorpgmaker.com - www.galaxiarpgmaker.com.br
    This work is licensed under a Creative Commons Atribuição-Uso não-comercial-Compartilhamento pela mesma licença 3.0 Unported License.
    Posted Image

     

    Índice de todas as aulas aqui

     

    Índice
    • 1.0 - Bem-vindos à minha primeira aula intermediária!
    • 1.1 - As coordenadas reais.
    • 1.2 - Os métodos da classe Game_Character
    • 1.3 - Conclusão

     

    1.0 - Bem-vindos à minha primeira aula intermediária!

     

          Olá scripter do RPG Maker! Venho aqui hoje dar minha primeira aula intermediária de RGSS! Essa aula não foi feita por acaso: decidi fazê-la para aprender sobre o seu assunto, já que estou a fazer um belo sistema que envolve a movimentação dos personagens no mapa! Nem tente ler esta aula caso não tenha conhecimentos básicos de RGSS, caso contrário ficará extremamente perdido! Para as pessoas que leram minhas aulas básicas, elas são praticamente suficientes para ler esta aula, embora eu não recomende isso. Chega de papo e vamos em frente!

     

    1.1 - As coordenadas reais.

     

          A primeira conclusão que vem na cabeça de qualquer bom programador RGSS é que o sistema comum de coordenadas não é efetivamente o sistema real de coordenadas gráficos, isto é, um evento que tem coordenadas x=1 e y=1 não está no ponto x=1 e y=1 da tela do jogo em si. Logicamente, a posição real seria x = 1 x 32 e y = 1 x 32
          Tá thiago_d_d, isto não é óbvio? Sim meu caro leitor. Acontece, porém, que nem esse sistema acima é o verdadeiro sistema de coordenadas REAL do RPG Maker. O sistema real na verdade seria x = 1 x 32 x 4 e y = 1 x 32 x 4. Eu, sinceramente, não tenho uma justificativa para a presença desse 4 multiplicando aí: eu adivinho e tenho quase certeza que esse sistema de coordenadas serve justamente para ter coordenadas mais precisas dos personagens e tiles na tela. Mas, quem poderá sabe o verdadeiro motivo?

     

          A questão é que todo o sistema de movimentação do RPG Maker não gira em torno das coordenadas de tile, muito menos da coordenadas gráficas, mas sim em torno dacoordenadas reais. Quando um evento se movimenta para baixo, por exemplo, seu y real aumenta aos poucos, até que se iguale ao y real da posição na qual ele se move.
          Não entendeu? Veja essa imagem:


    Posted Image

          Temos no exemplo um personagem que vai se mover da posição y = 1 para posição y = 2(ele vai descer). Essas suas posições tem essas coordenadas:


    Posição 1


    Posição de tile: y = 1
    Posição de gráfico: y = 1 x 32 = 32
    Posição real: y = 1 x 32 x 4 = 128

    Posição 2


    Posição de tile: y = 2
    Posição de gráfico: y = 2 x 32 = 64
    Posição real: y = 2 x 32 x 4 = 256

          Nessa movimentação, o y do personagem(que é 128) irá aumentar aos poucos, até que se iguale a 256. O y irá aumentar um pouco a cada frame, em uma certa quantidade que dependerá, justamente, da velocidade do personagem. Como dependerá? Veremos isso logo a seguir!

     

    1.2 - Os métodos da classe Game_Character

     

          Todo evento e até o jogador principal são um Game_Character. Essa magnífica classe cuida de toda a movimentação dos personagens do jogo, e nada vale mais pena do que analisá-la delicadamente, método por método. Iremos, obviamente, analisar somente os métodos mais importantes.

    initialize


    def initialize     @id=0     @x=0     @y=0     @real_x=0     @real_y=0     @tile_id=0     @character_name=""     @character_hue=0     @opacity=255     @blend_type=0     @direction=2     @pattern=0     @move_route_forcing=false     @through=false     @animation_id=0     @transparent=false     @original_direction=2     @original_pattern=0     @move_type=0     @move_speed=4     @move_frequency=6     @move_route=nil     @move_route_index=0     @original_move_route=nil     @original_move_route_index=0     @walk_anime=true     @step_anime=false     @direction_fix=false     @always_on_top=false     @anime_count=0     @stop_count=0     @jump_count=0     @jump_peak=0     @wait_count=0     @locked=false     @prelock_direction=0   end
    Temos aí que todas as características de um personagem são inicializadas e guardadas em variáveis. São as mais importante para o assunto:
    • @x e @y
      Guardam as coordenadas de tile do personagem.
    • @real_x e @real_y
      Guardam as coordenadas reais do personagem.
    • @tile_id
      Caso seja um evento que tenha um tile como gráfico, essa variável guarda a id do tile.
    • @character_name e @character_hue
      Guarda o nome do gráfico do personagem, assim como seu HUE(que determina a sua cor).
    • @direction e @original_direction
      Guardam a direção que o personagem olha, e sua direção original(2 = baixo, 4 = esquerda, 6 = direita, 8 = cima)
    • @pattern e @original_pattern
      Guardam a posição de movimento do personagem atual e a posição posição de movimento do personagem original(aquelas posições do gráfico, uma de quando tá parado, outra andando com o pé esquerdo, etc)
    • @move_type, @move_speed e @move_frequency
      Guardam o tipo de movimento atual do personagem, sua velocidade e a frequencia do movimento.

    moving?


      def moving?     return(@real_x!=@x*128or@real_y!=@y*128)   end
    O método testa se o real_x é igual ao x(lembre-se, em um movimento o real_x do personagem não se iguala ao real_x da nova posição, ele vai aumentando progressivamente) ou se o real_y é igual ao y, se não for, logicamente o personagem está se movendo.

    moveto(x,y)


      def moveto(x, y)     @x= x % $game_map.width     @y= y % $game_map.height     @real_x=@x*128     @real_y=@y*128     @prelock_direction=0   end
    TELEPORTA o personagem(sem animações) para uma posição. Observe que, para evitar que animações ocorram, o real_x e o real_y imediatamente assumem seus valores corretos.

    screen_x, screen_y


      def screen_x     return(@real_x- $game_map.display_x +3)/4+16   end   def screen_y     y =(@real_y- $game_map.display_y +3)/4+32     if@jump_count>=@jump_peak       n =@jump_count-@jump_peak     else       n =@jump_peak-@jump_count     end     return y -(@jump_peak*@jump_peak- n * n)/2   end
    Esses métodos retornam a posição gráfica(na tela) do personagem. São métodos com cálculos intrigantes, e prefiro não explicá-los, pois essa aula é apenas uma aula intermediária..

    update_move


      def update_move     distance =2**@move_speed     if@y*128>@real_y       @real_y=[@real_y+ distance,@y*128].min     end     if@x*128<@real_x       @real_x=[@real_x- distance,@x*128].max     end     if@x*128>@real_x       @real_x=[@real_x+ distance,@x*128].min     end     if@y*128<@real_y       # Mover para cima       @real_y=[@real_y- distance,@y*128].max     end     if@walk_anime       @anime_count+=1.5     elsif@step_anime       @anime_count+=1     end   end

              É aqui que ocorre a mágica do movimento. Primeiro, o método cálcula a distância que será adicionada ao real_x e/ou ao real_y, que é justamente 2 elevado a potência da velocidade do personagem. Observe que, quanto maior a velocidade do personagem, mais absurdamente distância ele andará a cada frame, sendo assim seu movimento será executado mais rápido(porém não mais vezes!).
          A linha [@real_y + distance, @y * 128].min e suas variantes asseguram que o real_x e o real_y vão ser adicionados pela distância calculada, porém não ultrapassarão o x e o y de tile reais.

     

     

    1.3 - Conclusão

     

          Então pessoal, é isso! A aula está bem simples, porém planejo ir atualizando ela conforme eu tiver tempo e for aprendendo mais, pois há mais coisas atrás da movimentação de personagens! Ainda não falei sobre pulos e sobre a mudança de pattern, isso será coisa que adicionarei depois. Espero que tenham gostado!


    [center]:mrm: :mrm: :mrm: