Em muitos jogos modernos em formato top, down, como The Legend of Zelda: A Link to the Past , os jogadores têm grande liberdade de movimento, pois podem se mover em qualquer uma das quatro direções principais (norte, sul, leste e oeste) bem como nas direções intermediárias. (Isso é um avanço em relação a jogos como The Legend of Zelda original , onde o único movimento possível era Norte / Sul / Leste / Oeste). Mesmo em jogos em que o jogador pode andar em mais do que as quatro direções básicas, ainda existem apenas quatro animações ambulantes correspondentes às quatro direções cardeais; qualquer que seja o ângulo em que o jogador esteja andando, o programa calcula a direção principal (Norte / Sul / Leste / Oeste) do movimento e ativa a animação de caminhada correspondente.
Neste artigo, demonstramos uma maneira eficiente de calcular a direção e definir a animação para os jogadores e personagens inimigos em um jogo com uma visão de cima para baixo (top, down).
O JOGADOR
Uma prática padrão na programação de jogos é manter vários objetos para cada personagem: por exemplo, um objeto de sprite para controlar a posição / rotação / movimento / detecção de colisão e outro sprite para armazenar as animações. (Por exemplo, você pode querer que seu personagem se mova em um ângulo de 45 graus no layout, mas não necessariamente deseja que as imagens de animação sejam rotacionadas nessa quantidade.)
Começamos criando dois sprites. Um sprite será nomeado Player e terá os comportamentos "8direções"(8-Direction), "CentralizarEM" (Scroll-To)e "RestritoAoLayout"(Scroll-To); esse objeto lida com o nosso movimento. Outro sprite será chamado PlayerAnimation e terá o comportamento "Fixar" (Pin), para que possamos configurá-lo para mover automaticamente em sincronia com o objeto player. Conseguimos isso com os eventos mostrados abaixo.
Observe: em particular, que ao fixar PlayerAnimation no Player, a opção "Position Only" deve ser selecionada, para evitar a rotação indesejada das imagens de animação.
A seguir, apresentamos dois métodos para definir as animações do Player corretamente. O primeiro método é direto, mas requer muitos eventos; o segundo usa um pouco de matemática e é muito mais eficiente.
MÉTODO 1
Neste método, primeiro calculamos o nome da direção principal na qual o jogador está se movendo, usando algumas comparações; em seguida, armazenamos o nome da direção correspondente em uma variável de instância (Chamaremos de DirectionName) e usamos essas informações para definir a animação. Se variavel "A" representa o ângulo do sprite do Player, as comparações são:
Usando a condição "Is Between Angles", definimos:
* se -45 <= A <= 45, defina DirectionName = "leste"
* se 45 <= A <= 135, defina DirectionName = "sul"
* se 135 <= A <= 225, defina DirectionName = "oeste"
* se 225 <= A <= 315, defina DirectionName = "norte"
(Nota técnica importante: aqui, estamos usando o ângulo da imagem do sprite "Player" para calcular a direção do movimento; o comportamento em 8 direções está configurado para sincronizar o ângulo da imagem, e os ângulos da imagem variam de 0 a 360). Em algumas situações, como usando o ângulo de movimento do comportamento do marcador, as medidas de ângulo usam o intervalo de -180 a 180. Nesse cenário, é necessário comparar valores usando a condição "Sistema: Comparar dois valores" para acessar o valor Bullet.AngleOfMotion e você precisará fazer algumas conversões nas comparações acima, por exemplo, 315 graus é igual a -45 graus, etc.)
Em seguida, usando as informações armazenadas em DirectionName e levando em consideração se o player está realmente se movendo, a animação correta deve ser configurada para reprodução. (Neste exemplo, os nomes das animações são WalkEast, WalkSouth, WalkWest e WalkNorth.) Quando o player não está se movendo, a animação deve ser interrompida. Os eventos abaixo detalham como fazer isso.
MÉTODO 2
Com um pouco de matemática, podemos obter o mesmo resultado com menos eventos (todas as quatro comparações podem ser obtidas com uma única ação). Nesse método, em vez de armazenar os nomes das direções em uma variável de instância DirectionName, criaremos um código numérico para cada um: 0 para leste, 1 para sul, 2 para oeste e 3 para norte; esses números serão armazenados em uma variável chamada DirectionCode. Criamos uma fórmula que converterá cada um dos intervalos de ângulo listados acima em um desses quatro números. Se variável "A" representa o ângulo da imagem do sprite, a fórmula é:
floor((((A + 45)% 360) / 90)))
Para ver como ele alcança o resultado desejado, veremos alguns exemplos.
* Se o ângulo do sprite for A = 30, A + 45 = 75, 75% 360 = 75, 75/90 = 0,833333 ... e floor (0,833333 ...) = 0, o que corresponde ao lado leste animação.
* Se o ângulo do sprite for A = 267, então A + 45 = 312, 312% 360 = 312, 312/90 = 3,46666 ... e floor (3,46666 ...) = 3, que corresponde ao norte animação.
* Se o ângulo do sprite é A = 352, então A + 45 = 397, 397% 360 = 37 (somente para números maiores que 360% 360 terá algum efeito), 37/90 = 0,41111 ... e piso (0,41111 ...) = 0, que corresponde à animação voltada para o leste.
Para esse método, as animações precisam ser nomeadas Walk0, Walk1, Walk2 e Walk3 (para leste, sul, oeste e norte, respectivamente); então, os eventos abaixo terão o mesmo efeito que os eventos do método nº 1 acima.
Traduzido e adaptado para português por Alysson Bárbara.
Tutorial Original: construct.net/en/tutorials/animation-management-in-8-direction-games-712