Tutorial de Scripting Visual (Ladrillos Lógicos)

En esta lección, comenzaremos a crear la lógica de movimiento básica para nuestro Player.

Usando solo los Logic Bricks de Cave Engine, implementaremos una mecánica simple de salto a través de lógica visual. Esto también te ayudará a entender una de las ideas más importantes detrás de los Logic Bricks: cómo eventos, condiciones y acciones trabajan juntas para controlar el comportamiento del juego.

En este caso, la lógica será muy simple:

1. Verificar si el jugador presionó la tecla de salto.
2. Comprobar si el Player puede saltar.
3. Si todo es correcto, llamar a la función de salto del Character Component del Player.

Este es un buen primer ejemplo porque saltar es una mecánica de juego muy común, pero también introduce la estructura básica que usarás muchas veces al crear juegos con Logic Bricks.

1. Agregando el Salto

Para comenzar a crear la lógica de movimiento del Player, primero necesitamos obtener los Events del juego.

El objeto Events te da acceso a información relacionada con la entrada, como teclas del teclado, botones del mouse y otras comprobaciones de eventos que ocurren durante el juego.

Dentro del área de edición de Logic Bricks, haz clic derecho para abrir el menú de búsqueda de nodos.

Para encontrar rápidamente un nodo, utiliza el campo de búsqueda identificado por el ícono de la lupa y escribe el nombre del nodo que deseas.

Los nodos Entity, Scene y Events se utilizan muy frecuentemente, por lo que ya aparecen resaltados en la parte superior de la ventana de búsqueda. Por eso, generalmente no necesitas buscarlos manualmente por nombre.

Selecciona Get Events para agregar un nodo de Events a tu lógica.

Ahora agrega el nodo Pressed.

Este nodo será responsable de verificar si una tecla específica está siendo presionada por el jugador.

En otras palabras, esta es la condición que le dirá a nuestra lógica: "el jugador quiere saltar ahora."

Selecciona la tecla que se usará para ejecutar el salto.

En la mayoría de los juegos, la tecla Space se usa comúnmente para saltar, así que la usaremos aquí también.

Después de configurar la tecla de salto, necesitamos comprobar si esta tecla fue realmente presionada por el jugador.

Para eso, utilizaremos un nodo If (Bool).

El nodo If (Bool) recibe un valor booleano, lo que significa un valor que puede ser True o False. Si la condición es verdadera, la lógica continúa a través de la salida True. Si la condición es falsa, continúa a través de la salida False.

En este caso, la condición será si la tecla Space está presionada o no.

Ahora, de la misma manera que agregamos el nodo Events, también necesitamos obtener nuestra Entity actual.

Esto es importante porque la acción de salto no pertenece al objeto Events. El objeto Events solo nos dice si la tecla fue presionada. El comportamiento real del salto pertenece a la Entity del Player, más específicamente a su Character Component.

A través del nodo Entity, podremos acceder a los componentes adjuntos al Player.

Desde la Output del Character Component, arrastra una conexión y busca Jump.

Este nodo será responsable de ejecutar el salto del personaje cuando se cumpla la condición.

Así que, en este punto, básicamente estamos diciendo:

"Cuando el jugador presione la tecla de salto, obtiene el Character Component del Player y llama a su función de salto."

Este será el flujo principal de la lógica de salto:

Entity → Character Component → Jump

Con este flujo, accedemos al componente del personaje desde la Entity y luego usamos su función de salto.

Ahora conecta la salida True del nodo If (Bool) a la entrada Flow del nodo Jump.

Esto significa que cuando la tecla Space es presionada, la condición será verdadera y el Player ejecutará el salto.

Si la tecla no está presionada, la condición será falsa y no sucederá nada.

Sin embargo, para que esta lógica realmente se ejecute, necesita estar conectada a un evento de Flow.

Los Logic Bricks no se ejecutan aleatoriamente. Necesitan un punto de entrada, que es el nodo que inicia el flujo de ejecución.

El nodo On Start se ejecuta solo una vez, cuando la Entity comienza. Esto es útil para lógica de inicialización, como establecer variables, preparar referencias o configurar algo al principio del juego.

El nodo On Update se ejecuta en cada frame. Esto es útil para la lógica de juego que necesita ser verificada constantemente, como movimiento, entrada, control de cámara o cualquier cosa que pueda cambiar mientras el juego está en ejecución.

Dado que necesitamos comprobar continuamente si el jugador presionó la tecla de salto, conectaremos nuestra lógica a On Update.

Esto garantiza que la verificación de la tecla de salto ocurra constantemente durante el juego.

Con esta lógica, el personaje ya debería poder saltar.

Para mantener tus Logic Bricks organizados, puedes seleccionar todos los nodos utilizados para crear esta funcionalidad haciendo clic y arrastrando con el botón derecho del mouse, o seleccionándolos individualmente mientras mantienes Shift.

Después de seleccionar los nodos, presiona C para crear un comentario.

Esta es una práctica de organización muy útil. A medida que tu lógica crece, los comentarios te ayudan a separar visualmente diferentes partes del comportamiento, como salto, movimiento, cámara, ataques, interacciones, y así sucesivamente.

Incluso si la lógica es simple ahora, acostumbrarte a organizar tus nodos desde el principio hará que tu proyecto sea mucho más fácil de entender más adelante.

2. Agregando la Verificación de Suelo

En este punto, probablemente notaste un pequeño problema: si seguimos presionando la tecla Space, el personaje puede seguir saltando repetidamente.

Esto sucede porque nuestra lógica aún no verifica si el personaje realmente puede saltar en ese momento. Solo comprueba si la tecla de salto fue presionada y luego llama inmediatamente a la función de salto.

En la mayoría de los juegos, no queremos que el jugador salte infinitamente en el aire. Por lo general, el jugador solo debe poder saltar cuando toca el suelo.

Afortunadamente, resolver esto en Cave es muy simple.

Para eso, utilizaremos el nodo On Ground.

El nodo On Ground devuelve un valor booleano que indica si el personaje está tocando el suelo o no.

Así que, ahora, en lugar de verificar solo una condición, verificaremos dos condiciones:

1. ¿Se presionó la tecla de salto?
2. ¿Está el personaje en el suelo?

Solo cuando ambas condiciones sean verdaderas, se debe ejecutar el nodo Jump.

La lógica se convierte en:

• Primero, verifica si se presionó la tecla Space.
• Si es verdadero, verifica si el Player está en el suelo.
• Si el Player está en el suelo, ejecuta Jump.
• Si el Player no está en el suelo, no haga nada.

Esto evita que el personaje salte infinitamente mientras ya está en el aire.

Con esta verificación de suelo añadida, la lógica de salto se vuelve mucho más correcta para un controlador de jugador básico.

Ahora el Player solo saltará cuando se presione la tecla de salto y el Character Component informe que el Player está actualmente en el suelo. Esta es la estructura básica que utilizarás para muchas acciones de juego en Cave: primero verifica la entrada, luego verifica si la acción está permitida y solo después ejecuta la acción.