Tutorial de Scripting Visual (Ladrillos Lógicos)

En esta lección, continuaremos desarrollando la lógica de movimiento básico para nuestro Player.

Utilizando las Logic Bricks de Cave Engine, crearemos la lógica responsable de hacer que el personaje camine y corra. A lo largo del camino, aprenderás cómo capturar la entrada del jugador, convertir esa entrada en una dirección de movimiento, controlar la velocidad de movimiento y mantener la lógica visual organizada.

Esta lección se basa en la lógica de salto creada anteriormente. Ahora, en lugar de reaccionar solo a una pulsación de tecla, leeremos múltiples teclas al mismo tiempo y las utilizaremos para definir dónde debe moverse el Player.

1. Agregando Secuencia

Para continuar desarrollando la lógica de movimiento de nuestro Player, aprenderemos a usar el nodo de Secuencia.

El nodo de Secuencia te permite crear múltiples salidas de Flujo a partir de una sola entrada. Esto es útil porque muchos sistemas de juego necesitan ejecutar más de una pieza de lógica desde el mismo evento.

Por ejemplo, nuestro evento de Actualización necesita verificar la lógica de salto cada cuadro, pero también necesitará verificar la lógica de movimiento cada cuadro. En lugar de crear todo en una sola cadena grande y confusa, podemos usar Secuencia para dividir el flujo en múltiples ramas organizadas.

De esta manera, el mismo evento de Actualización puede ejecutar diferentes bloques de lógica en cada cuadro de manera más limpia y controlada.

2. Creando la Lógica de Movimiento

Para crear el movimiento del Player, comenzaremos agregando el nodo de Eventos y luego el nodo de Activo.

El nodo de Activo verifica si una tecla se está manteniendo presionada. Esto es diferente de verificar si una tecla se presionó solo una vez. Para el movimiento, generalmente queremos saber si el jugador está manteniendo la tecla de manera continua, porque el personaje debe seguir moviéndose mientras la tecla sigue activa.

Haremos esto para todas las teclas de movimiento:

• W para moverse hacia adelante
• S para moverse hacia atrás
• A para moverse a la izquierda
• D para moverse a la derecha

La salida del nodo de Activo es un valor Bool. Una variable booleana solo puede tener dos estados: True o False.

Cuando convertimos este valor booleano a un Float usando el nodo de Bool A Float, obtenemos:

• 1 cuando el valor es True
• 0 cuando el valor es False

Esto nos permite usar el estado del teclado en operaciones matemáticas.

Por ejemplo, podemos restar el valor de S del valor de W para calcular el movimiento hacia adelante/hacia atrás. También podemos restar el valor de A del valor de D para calcular el movimiento hacia la izquierda/derecha.

Esto funciona porque cada tecla devuelve 0 o 1.

Por ejemplo, para el movimiento hacia adelante y hacia atrás:

• Si W está presionado y S no está presionado, el resultado es 1 - 0 = 1, por lo que el Player se mueve hacia adelante.
• Si S está presionado y W no está presionado, el resultado es 0 - 1 = -1, por lo que el Player se mueve hacia atrás.
• Si ninguna tecla está presionada, el resultado es 0 - 0 = 0, por lo que no hay movimiento en ese eje.
• Si ambas teclas están presionadas, el resultado es 1 - 1 = 0, por lo que se cancelan entre sí.

Con estos resultados, agregamos un nodo de Hacer Vector 3 y conectamos los valores calculados a los ejes X y Z, que serán responsables de definir la dirección del movimiento.

Ahora, conecta la primera salida de Entonces del nodo de Secuencia al flujo de esta lógica de movimiento, mientras que la otra salida de Entonces puede seguir siendo utilizada por la lógica de salto creada en la lección anterior.

Finalmente, obtén el Entity, accede a su Character Component y utiliza el nodo de Set Walk Direction. Conecta el vector creado por el Hacer Vector 3 al parámetro de dirección, para que el Character Component sepa hacia dónde debe moverse el Player.

Ahora necesitamos crear un limitador para controlar la velocidad de movimiento de nuestro Player.

En lugar de definir la dirección de movimiento directamente en Set Walk Direction, primero almacenaremos la dirección de movimiento en una propiedad. Esto nos da un mayor control porque podremos modificar esta dirección antes de aplicarla al personaje.

Abre la pestaña de Propiedades, crea una nueva propiedad, cambia su tipo a Vector3 y renómbrala a Move Dir.

Esta propiedad se utilizará para almacenar la dirección de movimiento del Player y servirá como base para los próximos ajustes en la lógica.

Haz clic en el ícono de engranaje que se muestra junto a la propiedad y selecciona Change Type para cambiar su tipo.

Luego, elige Vector3.

Ahora vuelve al Graph de tus Logic Bricks y establece la propiedad Move Dir que acabamos de crear.

Conecta la salida del nodo de Hacer Vector 3 al valor de la propiedad Move Dir.

Esto significa que, en lugar de aplicar directamente la dirección de movimiento al personaje, estamos almacenando ese vector en una propiedad para que podamos usarlo y modificarlo en las siguientes partes de la lógica.

Ahora que estamos almacenando la dirección de movimiento del personaje en la propiedad Move Dir, vamos a crear dos propiedades más de tipo Float:

• Walk Speed
• Run Speed

Estas propiedades definirán la velocidad del Player en cada estado de movimiento.

El uso de propiedades aquí es una buena práctica porque facilita ajustar el movimiento más adelante. En lugar de buscar valores codificados dentro del gráfico, simplemente puedes seleccionar la Entity y ajustar la velocidad de caminar y correr directamente desde la pestaña de Propiedades.

Ahora crea una propiedad más, esta vez de tipo Bool, llamada Is Running.

Esta propiedad almacenará el estado de carrera del personaje. Indicará a la lógica si el Player está corriendo actualmente o no, lo que nos permitirá elegir entre los valores de Walk Speed y Run Speed.

Ahora agrega un nodo de Activo para verificar si la tecla Shift se está manteniendo presionada.

Luego usa Set Is Running para definir la propiedad según esta condición. Cuando Shift está activo, Is Running debe establecerse en True, indicando que el personaje está corriendo.

Ahora definiremos la Walk Direction usando la dirección almacenada en la propiedad Move Dir, mientras aplicamos la velocidad correcta para cada estado de movimiento.

Para hacer esto, agrega un nodo de If que verifica si la propiedad Is Running es True o False.

Si el resultado es True, obtén el valor de Move Dir y multiplícalo por la propiedad Run Speed.

Si el resultado es False, obtén el valor de Move Dir y multiplícalo por la propiedad Walk Speed.

Finalmente, conecta el resultado de esta multiplicación al nodo de Set Walk Direction.

De esta manera, la dirección de movimiento permanece igual, pero su intensidad cambia dependiendo de si el Player está caminando o corriendo.

Ahora necesitamos resolver un pequeño problema.

Si mueves el personaje en diagonal, puede que notes que se mueve más rápido que cuando solo camina hacia adelante, hacia atrás, hacia la izquierda o hacia la derecha. Esto sucede porque combinar dos ejes de movimiento crea un vector con una magnitud mayor.

Por ejemplo, mover solo hacia adelante crea una dirección como esta:

(0, 0, 1)

Pero mover hacia adelante y hacia la derecha al mismo tiempo crea algo como esto:

(1, 0, 1)

Ese vector diagonal es más largo que un vector de un solo eje, lo que hace que el personaje se mueva más rápido en diagonal.

Para corregir este comportamiento, normalizaremos el vector de dirección antes de almacenarlo en la propiedad Move Dir.

Primero, obtén la Longitud del vector generado por Hacer Vector 3.

Luego añade un nodo de If para verificar si este valor es mayor que 0.

Esta verificación es importante porque no debemos normalizar un vector vacío. Un vector con longitud 0 significa que no se está presionando ninguna tecla de movimiento, por lo que no hay dirección que normalizar.

Si la condición es verdadera, usa el nodo de Normalizado para obtener la versión normalizada del vector.

De lo contrario, usa el vector original.

Finalmente, conecta el resultado al nodo de Set Property de Move Dir.

Esto preserva la dirección de movimiento, pero mantiene su magnitud consistente, asegurando que el personaje se mueva a la misma velocidad en todas las direcciones.

3. Usando Eventos

Hay formas más organizadas de estructurar el flujo de nuestra lógica dentro de Logic Bricks.

Además de comentarios y el nodo de Secuencia, también podemos usar Eventos para hacer que el sistema sea más limpio y fácil de entender.

Los eventos permiten separar un bloque específico de lógica y llamarlo desde otro lugar en el gráfico. Esto es especialmente útil a medida que tu gráfico crece, porque evita que todo esté conectado directamente a On Update en una cadena grande.

Ahora vamos a crear un nuevo evento llamado Move Player.

Luego conecta este evento al flujo del bloque de lógica de movimiento del Player.

Con esto, en lugar de mantener toda la lógica de movimiento directamente conectada a On Update, podemos simplemente llamar al evento Move Player dentro de la secuencia de On Update.

Esto hace que el flujo sea más limpio, modular y fácil de entender, especialmente a medida que la lógica del proyecto se vuelve más compleja.

En este punto, el Player ya tiene un sistema de movimiento básico creado con Logic Bricks.

La lógica ahora verifica las teclas de movimiento, calcula una dirección de movimiento, normaliza la dirección para evitar un movimiento diagonal más rápido, la almacena en la propiedad Move Dir, verifica si el jugador está corriendo, aplica la velocidad correcta y finalmente envía el resultado al Character Component a través de Set Walk Direction.