Tutorial de Scripting Visual (Blocos de Lógica)

Nesta lição, continuaremos desenvolvendo a lógica básica de movimento para o nosso Player.

Usando o Logic Bricks do Cave Engine, criaremos a lógica responsável por fazer o personagem andar e correr. Ao longo do caminho, você aprenderá a capturar a entrada do jogador, converter essa entrada em uma direção de movimento, controlar a velocidade do movimento e manter a lógica visual organizada.

Esta lição se baseia na lógica de salto criada anteriormente. Agora, em vez de apenas reagir a uma única tecla pressionada, leremos várias teclas ao mesmo tempo e usaremos elas para definir onde o Player deve se mover.

1. Adicionando o Sequence

Para continuar desenvolvendo a lógica de movimento para o nosso Player, aprenderemos a usar o nó Sequence.

O nó Sequence permite que você crie múltiplas saídas de Flow a partir de uma única entrada. Isso é útil porque muitos sistemas de gameplay precisam executar mais de uma peça de lógica a partir do mesmo evento.

Por exemplo, nosso evento On Update precisa verificar a lógica de salto a cada quadro, mas também precisará verificar a lógica de movimento a cada quadro. Em vez de criar tudo em uma única e confusa cadeia, podemos usar o Sequence para dividir o fluxo em múltiplos ramos organizados.

Dessa forma, o mesmo evento On Update pode executar diferentes blocos de lógica a cada quadro de uma maneira mais limpa e controlada.

2. Criando a Lógica de Movimento

Para criar o movimento do Player, começaremos adicionando o nó Events e depois o nó Active.

O nó Active verifica se uma tecla está sendo mantida pressionada no momento. Isso é diferente de verificar se uma tecla foi pressionada apenas uma vez. Para movimento, geralmente queremos saber se o jogador está mantendo a tecla pressionada, pois o personagem deve continuar se movendo enquanto a tecla permanecer ativa.

Faremos isso para todas as teclas de movimento:

• W para mover para frente
• S para mover para trás
• A para mover para a esquerda
• D para mover para a direita

A saída do nó Active é um valor Bool. Uma variável booleana pode ter apenas dois estados: True ou False.

Quando convertemos esse valor booleano em um Float usando o nó Bool To Float, obtemos:

• 1 quando o valor é True
• 0 quando o valor é False

Isso nos permite usar o estado do teclado em operações matemáticas.

Por exemplo, podemos subtrair o valor de S do valor de W para calcular o movimento para frente/para trás. Também podemos subtrair o valor de A do valor de D para calcular o movimento para a esquerda/direita.

Isso funciona porque cada tecla retorna 0 ou 1.

Por exemplo, para movimento para frente e para trás:

• Se W estiver pressionada e S não estiver pressionada, o resultado é 1 - 0 = 1, então o Player se move para frente.
• Se S estiver pressionada e W não estiver pressionada, o resultado é 0 - 1 = -1, então o Player se move para trás.
• Se nenhuma tecla estiver pressionada, o resultado é 0 - 0 = 0, então não há movimento nesse eixo.
• Se ambas as teclas estiverem pressionadas, o resultado é 1 - 1 = 0, então elas se cancelam.

Com esses resultados, adicionamos um nó Make Vector 3 e conectamos os valores calculados aos eixos X e Z, que serão responsáveis por definir a direção do movimento.

Agora conecte a primeira saída Then do nó Sequence ao fluxo desta lógica de movimento, enquanto a outra saída Then pode continuar sendo usada pela lógica de salto criada na lição anterior.

Por fim, obtenha a Entity, acesse seu Character Component e use o nó Set Walk Direction. Conecte o vetor criado pelo Make Vector 3 ao parâmetro de direção, para que o Character Component saiba onde o Player deve se mover.

Agora precisamos criar um limitador para controlar a velocidade de movimento do nosso Player.

Em vez de definir a direção de movimento diretamente em Set Walk Direction, primeiro armazenaremos a direção de movimento em uma propriedade. Isso nos dará mais controle porque poderemos modificar essa direção antes de aplicá-la ao personagem.

Abra a aba Properties, crie uma nova propriedade, mude seu tipo para Vector3 e renomeie-a para Move Dir.

Essa propriedade será usada para armazenar a direção de movimento do Player e servirá como base para os próximos ajustes na lógica.

Clique no ícone de engrenagem exibido ao lado da propriedade e selecione Change Type para mudar seu tipo.

Então escolha Vector3.

Agora volte para o Graph dos seus Logic Bricks e defina a propriedade Move Dir que acabamos de criar.

Conecte a saída do nó Make Vector 3 ao valor da propriedade Move Dir.

Isso significa que, em vez de aplicar a direção de movimento diretamente ao personagem, estamos armazenando esse vetor em uma propriedade para que possamos usá-lo e modificá-lo nas próximas partes da lógica.

Agora que estamos armazenando a direção de movimento do personagem na propriedade Move Dir, vamos criar mais duas propriedades do tipo Float:

• Walk Speed
• Run Speed

Essas propriedades definirão a velocidade do Player em cada estado de movimento.

Usar propriedades aqui é uma boa prática porque torna o movimento mais fácil de ajustar mais tarde. Em vez de procurar valores codificados dentro do gráfico, você pode simplesmente selecionar a Entity e ajustar a velocidade de caminhada e corrida diretamente na aba de Propriedades.

Agora crie mais uma propriedade, desta vez do tipo Bool, chamada Is Running.

Essa propriedade armazenará o estado de corrida do personagem. Ela informará à lógica se o Player está atualmente correndo ou não, permitindo-nos escolher entre os valores de Walk Speed e Run Speed.

Agora adicione um nó Active para verificar se a tecla Shift está sendo mantida pressionada.

Em seguida, use Set Is Running para definir a propriedade com base nessa condição. Quando Shift estiver ativo, Is Running deve ser definido como True, indicando que o personagem está correndo.

Agora definiremos a Walk Direction usando a direção armazenada na propriedade Move Dir, ao mesmo tempo aplicando a velocidade correta para cada estado de movimento.

Para fazer isso, adicione um nó If que verifica se a propriedade Is Running é True ou False.

Se o resultado for True, pegue o valor de Move Dir e multiplique pela propriedade Run Speed.

Se o resultado for False, pegue o valor de Move Dir e multiplique pela propriedade Walk Speed.

Por fim, conecte o resultado dessa multiplicação ao nó Set Walk Direction.

Dessa forma, a direção de movimento permanece a mesma, mas sua intensidade muda dependendo de o Player estar andando ou correndo.

Agora precisamos resolver um pequeno problema.

Se você mover o personagem na diagonal, pode notar que ele se move mais rápido do que quando anda apenas para frente, para trás, para a esquerda ou para a direita. Isso acontece porque combinar dois eixos de movimento cria um vetor com uma magnitude maior.

Por exemplo, mover apenas para frente cria uma direção como esta:

(0, 0, 1)

Mas mover para frente e para a direita ao mesmo tempo cria algo como:

(1, 0, 1)

Esse vetor diagonal é mais longo do que um vetor de um único eixo, o que faz com que o personagem se mova mais rápido na diagonal.

Para corrigir esse comportamento, normalizaremos o vetor de direção antes de armazená-lo na propriedade Move Dir.

Primeiro, obtenha a Length do vetor gerado pelo Make Vector 3.

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

Essa verificação é importante porque não devemos normalizar um vetor vazio. Um vetor com comprimento 0 significa que nenhuma tecla de movimento está sendo pressionada, então não há direção a normalizar.

Se a condição for verdadeira, use o nó Normalized para obter a versão normalizada do vetor.

Caso contrário, use o vetor original.

Por fim, conecte o resultado ao nó Set Property de Move Dir.

Isso preserva a direção do movimento, mas mantém sua magnitude consistente, garantindo que o personagem se mova na mesma velocidade em todas as direções.

3. Usando Eventos

Existem maneiras mais organizadas de estruturar o fluxo da nossa lógica dentro dos Logic Bricks.

Além de comentários e do nó Sequence, também podemos usar Events para tornar o sistema mais limpo e fácil de entender.

Eventos permitem que você separe um bloco específico de lógica e o chame de outro lugar no gráfico. Isso é especialmente útil à medida que seu gráfico cresce, pois evita ter tudo conectado diretamente ao On Update em uma única grande cadeia.

Agora vamos criar um novo evento chamado Move Player.

Em seguida, conecte este evento ao fluxo do bloco de lógica de movimento do Player.

Com isso, em vez de manter toda a lógica de movimento diretamente conectada ao On Update, podemos simplesmente chamar o evento Move Player dentro da sequência On Update.

Isso torna o fluxo mais limpo, modular e fácil de entender, especialmente à medida que a lógica do projeto se torna mais complexa.

Neste ponto, o Player já possui um sistema básico de movimento criado com Logic Bricks.

A lógica agora verifica as teclas de movimento, calcula uma direção de movimento, normaliza a direção para evitar movimento diagonal mais rápido, armazena isso na propriedade Move Dir, verifica se o Jogador está correndo, aplica a velocidade correta e, finalmente, envia o resultado para o Character Component através de Set Walk Direction.