Tutorial de Scripting Visual (Blocos de Lógica)

Nesta lição, começaremos a integrar animações na lógica do Player.

Neste ponto, o Player já pode se mover e pular. Agora precisamos fazer com que o personagem reaja visualmente a esses estados, reproduzindo as animações corretas, como idle, walking, running e falling.

A ideia principal é simples: usaremos o estado atual do personagem para decidir qual animação deve ser reproduzida.

Por exemplo:

• Se o Player estiver no chão e não se movendo, reproduza a animação idle.
• Se o Player estiver no chão e se movendo, reproduza a animação walking.
• Se o Player estiver correndo, reproduza a animação running.
• Se o Player não estiver no chão, reproduza a animação falling.

Este é um dos padrões mais comuns ao criar um controlador de personagem. A lógica de movimento controla o que o personagem está fazendo, e a lógica de animação lê essas informações para decidir o que o jogador deve ver.

1. Criando a Lógica de Execução da Animação

Agora que aprendemos a criar e organizar eventos, vamos criar um novo evento para o bloco de lógica de animação chamado Update Animations.

Este evento será responsável por atualizar o estado da animação do Player.

A primeira coisa que faremos é conectar este evento a um nó If que verifica se o personagem está atualmente no chão ou não. Esta informação será usada para decidir qual animação deve ser reproduzida.

Por exemplo, quando o Player estiver no chão, podemos reproduzir animações idle, walk ou run. Quando o Player não estiver no chão, podemos reproduzir uma animação de queda.

Em seguida, precisamos acessar o Animation Component, que é responsável por gerenciar e reproduzir as animações do personagem.

Para fazer isso, primeiro obtemos a Entity, depois usamos o nó Child para obter o objeto filho chamado Mesh, que é o objeto de malha do nosso Player. A partir desta Entity filho, podemos acessar o Animation Component.

Como provavelmente precisaremos acessar o Animation Component várias vezes, podemos transformar os nós Get Entity, Get Child e Get Animation Component em uma função reutilizável.

Para fazer isso, selecione os nós desejados, clique com o botão direito e escolha Promote Selection To Function.

Isso criará uma função contendo essa lógica, tornando o Gráfico mais limpo e fácil de entender. Também nos permite reutilizar esse mesmo fluxo em outras partes do Logic Brick sem ter que recriar os mesmos nós novamente.

Vamos renomear essa função para Play Animation.

Usar nomes claros e descritivos é muito importante ao trabalhar com lógica visual. À medida que seu gráfico cresce, bons nomes ajudarão você a entender rapidamente o que cada evento, função e bloco de lógica é responsável.

Agora clique duas vezes na função Play Animation para abri-la e editá-la.

Em seguida, clique com o botão direito no nó Function Inputs e adicione dois novos pinos de entrada.

A primeira entrada será:

• Animation, do tipo String.

Essa entrada será usada para informar o nome da animação que deve ser reproduzida.

A segunda entrada será:

• Blend, do tipo Float.

Essa entrada será usada para controlar o tempo de transição entre animações.

Esses parâmetros tornam a função muito mais flexível.

Em vez de criar um bloco diferente de nós para cada animação, podemos usar a mesma função Play Animation e simplesmente passar um nome de animação diferente e um valor de blend toda vez que a chamamos.

A partir da saída do Get Animation Component, adicione o nó Play By Name.

Este nó é responsável por reproduzir uma animação com base em seu nome.

Em seguida, conecte os parâmetros Animation e Blend que criamos no nó Function Inputs aos campos correspondentes do nó Play By Name.

Isso significa que toda vez que a função Play Animation for chamada, ela receberá o nome da animação e o tempo de blend, e então passará esses valores para Play By Name.

Não se esqueça de habilitar a opção Loop no nó Play By Name.

Com Loop habilitado, a animação continuará sendo reproduzida enquanto estiver ativa, em vez de parar quando atinge o último quadro. Isso é especialmente importante para animações como idle, walking, running e falling, pois normalmente precisam continuar sendo reproduzidas continuamente.

Finalmente, conecte a saída Flow do nó Play By Name aos Function Outputs, finalizando a execução da função Play Animation.

Agora é muito mais fácil reproduzir as animações do nosso personagem.

Vá de volta ao nó If que verifica se o Player está no chão ou não, e use a função Play Animation.

Quando a condição for True, o que significa que o Player está no chão, chame a função passando "p-idle" como o parâmetro de animação. Essa é a animação usada quando o personagem está parado.

Quando a condição for False, o que significa que o Player não está no chão, chame a função passando "p-fall". Essa é a animação usada quando o personagem está no ar.

Para ambos os casos, use 0.1 como o valor de Blend. Isso dá à animação um pequeno tempo de transição, tornando a mudança mais suave em vez de mudar instantaneamente de uma animação para outra.

Agora só precisamos chamar o evento Update Animations dentro do fluxo do evento Move Player.

Dessa forma, toda vez que a lógica de movimento do Player for atualizada, a lógica de animação também será atualizada.

Com isso, o Player já poderá alternar entre p-idle e p-fall dependendo de seu estado atual. Quando o Player está no chão, ele reproduzirá a animação idle. Quando o Player está no ar, ele reproduzirá a animação de queda.

Perfeito. Agora vamos continuar desenvolvendo a lógica de animação do Player adicionando as animações de movimento.

Para fazer isso, obtenha a Walk Direction e use o nó Length para medir a intensidade do vetor de movimento.

O comprimento do vetor de movimento nos diz se o personagem está se movendo ou não.

Em seguida, adicione um nó If para verificar se este valor é maior que 0.

Se o resultado for True, significa que o personagem está se movendo, então podemos reproduzir a animação de caminhada p-walk.

Se o resultado for False, significa que o personagem não está se movendo, então devemos reproduzir a animação idle p-idle.

Isso faz com que o Player mude automaticamente entre estar parado e caminhando com base em seu movimento.

Agora há dois outros detalhes para completar o comportamento da animação de movimento do nosso personagem:

Primeiro, precisamos reproduzir a animação de corrida quando o Player está correndo.

Segundo, precisamos fazer com que o Player olhe na direção em que está se movendo.

Para controlar as animações de caminhada e corrida, adicione um nó Sequence logo após a verificação que verifica se o Player está se movendo.

Em seguida, obtenha a propriedade Is Running e use um nó If para verificar seu valor.

Se Is Running for True, reproduza a animação de corrida.

Se Is Running for False, reproduza a animação de caminhada.

Dessa forma, o Player não só saberá se está se movendo ou parado, mas também se deve usar a animação de caminhada ou corrida enquanto se move.

Na segunda saída Then da sequência que acabamos de adicionar, use o nó Look At Smooth.

Este nó fará a rotação do personagem suavemente, fazendo-o olhar na direção em que está se movendo. Isso torna o movimento muito mais natural, pois a malha do personagem se voltará visualmente na mesma direção que o movimento.

Precisamos multiplicar o valor de Get Walk Direction por -1 antes de enviá-lo para Look At Smooth.

Isso inverte o vetor de direção e corrige a direção que a malha do personagem está enfrentando. Dependendo de como o modelo do personagem foi importado ou orientado, a malha visual pode enfrentar a direção oposta ao vetor de movimento. Multiplicando por -1 corrige isso e faz com que o personagem enfrente a direção correta enquanto se move.

Depois disso, conecte a direção já multiplicada ao nó Look At Smooth.

Em seguida, também precisamos fornecer o Transform do objeto que será rotacionado.

Para fazer isso, acesse a Entity, depois obtenha o Mesh do Player e use o nó Get Transform.

Esta transformação deve ser conectada ao Look At Smooth, garantindo que a rotação seja aplicada ao objeto correto, que é a malha visível do personagem.

Neste ponto, a lógica de animação do Player já está muito mais completa.

O personagem agora pode alternar entre animações idle, falling, walking e running com base em seu estado atual. Ele também se rotaciona suavemente para enfrentar a direção do movimento, tornando o controlador mais natural e visualmente conectado à lógica de gameplay.