Abrir puertas con llaves

Ahora que el jugador puede recoger llaves en el juego, añadirás la función de desbloquear y abrir puertas cuando el jugador haya recogido la llave requerida. En esta parte del tutorial, modificarás el blueprint BP_DoorFrame y explorarás las funciones en los blueprints.

Las puertas desbloqueables proporcionan una forma de controlar el flujo del juego y proporcionan una sensación de progreso al jugador. El proyecto en el que estamos trabajando ahora mismo se divide en salas. Por lo tanto, coger llaves para abrir puertas proporciona una ruta lógica de progreso al jugador.

Antes de empezar

Asegúrate de que comprendes los temas tratados en las secciones anteriores de la serie de tutoriales sobre El diseño de una aventura de puzles:

• Aspectos básicos de los blueprints, incluidas las interfaces de Blueprint.

• Creación de variantes de un objeto con una variable de mapa.

Necesitarás los siguientes recursos creados en el tutorial anterior, Crear una llave:

• BP_Key

• Biblioteca de funciones de Blueprint BPL_FPGame

• Interfaz de Blueprint BPI_PlayerKeys

• Tres instancias de BP_DoorFrame colocadas en tu nivel entre habitaciones o pasillos

Añade opciones de color a la puerta

Dado que la plantilla de primera persona ya cuenta con un blueprint de puerta, puedes modificar el blueprint existente para añadir la función de desbloquear puertas con una llave. 

Tu puerta necesita algunos requisitos para funcionar con el sistema de llave que definiste en la parte anterior de este tutorial. Al igual que la llave, la puerta necesita saber que el actor que interactúa con ella implementa la interfaz BPI_PlayerKeys. 

La puerta debería cambiar de color para coincidir con la llave que acepta, lo que significa que necesita saber qué tipo de llave puede abrirla. Por último, necesita la misma variable KeyMap con combinaciones de color rojo, amarillo y azul.

Cómo crear variables para interactuar con el jugador y las llaves

Para añadir nuevas variables al blueprint BP_DoorFrame, sigue estos pasos:

1. Ve al explorador de contenido, accede a la carpeta LevelPrototyping > Interactable > Door y abre el blueprint BP_DoorFrame.

2. En la sección Variables del panel My Blueprint, añade una nueva variable llamada UseKey de tipo booleano. Esto determina si la puerta necesita una llave para abrirse.

3. Crea otra variable llamada RequiredKey del tipo Enum Key Type. Esto determina la llave necesaria para abrir la puerta. 

   

4. Haz clic en el icono de ojo que hay junto a ambas variables para que el ojo esté abierto, haciéndolas de este modo editables.

5. Selecciona la variable UseKey. En el panel Detalles, introduce Configuración en Categoría.

6. Selecciona RequiredKey y cambia su categoría a Setup.

7. Crea una nueva variable llamada Other Actor del tipo Actor > Referencia a objeto. Esto almacena al actor que interactúa con la puerta y lo usarás para comprobar si el jugador ha entrado en el volumen de la puerta.

   

Cómo crear la variable de asignación de llaves

Al igual que en BP_Key, añadirás la variable de asignación que mapea los tipos de llave con los colores de los materiales. Sin embargo, en el caso de la puerta, te interesa que las mallas de puerta cambien de forma, por lo que no añadirás nuevas formas de malla al mapa.

Para compilar la variable KeyMap de la puerta, sigue estos pasos:

1. Crea una variable llamada KeyMap, del tipo Enum Key Type. 

2. Haz clic en esta variable y, en el panel de detalles, haz clic en el menú desplegable de contenedor y selecciona Mapa. 

3. Cambia el tipo de valor del mapa a Struct Key Data.

   

4. Compila el blueprint para añadir los valores de KeyMap.

5. En la sección Valor por defecto del mapa, añade (+) 3 nuevos elementos al Key Map. 

   Cuando añadas la primera entrada, cambia el tipo a otro color para poder seguir añadiendo nuevas entradas. No se puede añadir la misma entrada más de una vez.

   

6. Para cada elemento del mapa, añade el material de llave correspondiente:

   1. M_BasicColor_Yellow

   2. M_BasicColor_Red

   3. M_BasicColor_Blue

   

7. Para cada elemento, asegúrate de que la malla de llave esté establecida en None. Para eliminar una malla, haz clic en el menú desplegable y selecciona Borrar encima de la lista. 

8. Guarda y compila el blueprint de puerta.

Cómo añadir lógica de blueprint de cambio de color

Una vez configuradas las variables, puedes añadir la función de cambio de color modificando el grafo de Blueprint.

Primero, debes cambiar la puerta para que tenga las opciones de color rojo, azul y amarillo controladas por la nueva variable RequiredKey que has añadido. La puerta debería cambiar de color a cuando la instales en el nivel, no cuando empiece la jugabilidad. Por lo tanto, utilizarás la pestaña Construction Script para crear esta función. 

Para agregar las opciones de color de la puerta, sigue estos pasos:

1. Ve a la pestaña Construction Script de la puerta, donde puedes añadir una función para cuando se cree la puerta. En el grafo, busca el nodo morado de la Construction Script que inicia la lógica de esta función.

2. En el nodo de Sequence que está conectado a Construction Script, usa Añadir pin (+) para crear un pin más, llamado Then 2, que podrás utilizar para seguir ampliando la cadena.

   

   El nodo Sequence se utiliza para compilar una secuencia de acciones, donde Then 0 se ejecuta primero, Then 1 después y así sucesivamente, en función de cuántos pines decidas añadir. Estos ayudan a organizar tu grafo y evitan que una cadena lógica se alargue demasiado.

3. Arrastra el pin Then 2 hasta una parte vacía del grafo y crea un nodo Branch. 

4. Arrastra el pin Condition del nodo Branch y crea un nodo Get Use Key. Ahora, el nodo Branch prueba si la puerta debe utilizar llaves o no. 

   

5. Arrastra el pin True del nodo Branch y crea un nodo Fn BPLSet Key. Esta es la función de biblioteca que aplica un nuevo color de material (y una malla, si se ha proporcionado) a una matriz de mallas estáticas.

6. Arrastra el pin de Matriz de mallas estáticas del nodo Fn BPLSet Key y crea un nodo Make Array. 

7. Haz clic en el botón de Añadir pin (+) del nodo Make Array.

8. Desde el nodo Make Array, arrastra el primer pin, [0], y crea un nodo Get Door. 

   Si observas la lista Variables > Componentes del panel Mi Blueprint, verás que la puerta tiene los componentes de malla estática Door y Door2. Estos son los colores que quieres que cambien.

9. Arrastra el segundo pin, [1], y crea un nodo Get Door 2. Esto crea una matriz basada en los dos componentes de malla estática, Door y Door 2. 

10. Desde el nodo Fn BPLSet Key, arrastra el pin Key Map y crea un nodo Get Key Map. Es una referencia a la variable KeyMap de la puerta.

11. A continuación, arrastra el pin Llave y crea un nodo Get Required Key, que es una referencia a la variable RequiredKey que has añadido antes.

12. Compila y guarda el blueprint.

La secuencia de comandos de construcción de la puerta ahora debería tener lo siguiente después del pin Then 3 del nodo Sequence:

Aquí tienes una versión de esta lógica que puedes copiar:

Probar los colores de la puerta

Después de asignar un color al objeto de juego puerta, puedes configurar las puertas para que no se abran a menos que el jugador tenga la llave correcta.

En tu nivel, selecciona una de tus instancias de BP_DoorFrame.

En el panel de detalles , introduce Key en el campo de búsqueda de la parte superior. Aparecerán dos opciones: Use Key y Required Key. Cambia la Required Key a un tipo de llave diferente. El color de la puerta debería cambiar para coincidir con el tipo de llave.

Te recordamos que esta es la ventaja de usar la pestaña del grafo Construction Script en el editor de blueprints. Puedes ver cómo se producen los cambios en el editor de niveles en lugar de tener que esperar a entrar en el modo de juego.

Compilar lógica de puertas basada en llaves

A continuación, puedes compilar la función para comprobar qué llaves tiene el jugador. Para ello, definirás una función personalizada nombrada fnHasKey en el blueprint BP_DoorFrame que compruebe si el jugador tiene la llave necesaria.   

Crear una función que compruebe si hay llaves

Esta función comparará la llave requerida de la puerta con la matriz de llaves del personaje jugable y devolverá un valor verdadero o falso (booleano). Usarás una variable local para ese valor de retorno booleano.

Para crear una función con una variable local, sigue estos pasos:

1. En el blueprint BP_DoorFrame, en el panel My Blueprint, utiliza Añadir (+) junto a la sección Funciones. Esto es similar a añadir una variable, pero en esta ocasión, estás añadiendo una función. 

2. Llama a la nueva función fnHasKey. 

   

3. Dado que una función puede tener su propio conjunto de nodos, se abre en su propia pestaña fnHasKey con un grafo de nodo independiente. Si cierras esta pestaña y necesitas volver a abrirla, haz doble clic en la función en la lista Funciones.

4. En el panel Mi Blueprint, verás una nueva sección en la parte inferior llamada Variables locales (FnHasKey). Crea una nueva variable local desde la opción Añadir (+) que hay junto a esa sección. 

5. Llama a la variable HasRequiredKey y establece que su tipo sea booleano.

   

   Las variables locales son similares a las variables normales, pero locales para una función concreta. Son útiles para almacenar valores temporales mientras se ejecuta la función. Después, puedes devolver este valor al resto del blueprint mediante un nodo Return.

Con la función configurada, puedes añadir lógica que compruebe si el jugador tiene la llave correcta.

Para comprobar si el actor del volumen de puerta tiene la llave necesaria, sigue estos pasos:

1. Arrastra el pin del nodo de entrada de la función fnHasKey y crea un nodo Sequence. Este nodo organiza la lógica de la función en una secuencia de acciones que se ejecutan en orden.

2. Arrastra el pin Then 0 del nodo Sequence y crea un nodo Fn BPIGet Keys (Message). Esta es la función de la interfaz que devuelve una matriz de llaves que el jugador ya ha encontrado.

3. Arrastra el pin Target del nodo Fn BPIGet Keys y crea un nodo Get Other Actor. Cuando hayas configurado el grafo de eventos de la puerta, esta variable almacenará el actor que se solapa con el volumen de la puerta.

   

4. Arrastra la variable local HasRequiredKey cerca del nodo Fn BPIGet Keys y selecciona Establecer.

5. Arrastra el pin Exec del nodo FN BPIGet Keys y conéctalo al nodo Set HasRequiredKey.

6. Desde el nodo Set HasRequiredKey, arrastra el pin HasRequiredKey y crea un nodo Contains Item, que aparecerá en la sección Matriz de la búsqueda. Este nodo comprueba si un elemento específico está en una matriz y devuelve true o false.

   También puedes buscar Array Contains Item para limitar la búsqueda a esa opción en particular.

7. Desde el nodo Contains Item, arrastra el pin Target Array (el pin cuadrado) y conéctalo al pin Llaves que tienes del nodo Fn BPIGet Keys. 

8. Arrastra el pin Item to Find (que parece un círculo) del nodo Contains Item y crea un nodo Get Required Key.

  Este es el aspecto que debería tener el grafo de tu función por ahora:

Esta secuencia de acciones comprueba si las llaves de OtherActor (variable) contienen RequiredKey (variable). Si es así, establecerá HasRequiredKey como true. 

Ahora, pasa el resultado HasRequiredKey al resto del blueprint. Para ello, usa un nodo Return, que detiene la ejecución de una función y devuelve un valor al blueprint que realizó la llamada a la función. 

Para finalizar la función con un nodo Return , sigue estos pasos:

1. En el nodo Sequence, arrastra el pin Then 1, busca Return en la lista de acciones de nodo y selecciona Add Return Node.

2. Para que la función devuelva un valor, necesita una salida. Haz clic en el nodo Return para resaltarlo.

3. En el panel Detalles , utiliza Añadir (+) junto a la sección Salidas en la parte inferior. Esto añade una nueva salida, que es el valor que pasa desde esta función.

4. Llama a esta salida KeyFound y cambia su tipo a booleano.

5. De vuelta en el grafo, arrastra el pin Key Found del nodo Return y crea un nodo Get HasRequiredKey.

El grafo completo de la función FnHasKey debería tener el siguiente aspecto:

Cerrar y abrir puertas con llaves

Ahora puedes modificar la puerta para que se abra si se cumplen todas las condiciones necesarias. 

Tal y como sucedía con la llave, tendrás que comprobar si el personaje implementa la interfaz BPI_PlayerKeys (la “hoja de permiso” del jugador) antes de que pueda intentar abrir una puerta que utiliza llaves.

Antes de abrirse, la puerta debe comprobar que se cumplen las siguientes condiciones:

• La puerta está configurada para utilizar llaves (UseKey = True).

• El actor solapado es el jugador (implementa BPI_PlayerKeys).

• El jugador dispone del tipo de llave necesaria.

Para probar si el actor que interactúa con la puerta es el jugador, sigue estos pasos:

1. En el grafo de eventos de BP_DoorFrame, busca el nodo Event ActorBeginOverlap. Esta colección de nodos controla lo que sucede cuando un personaje entra en el volumen de colisión de la puerta. Añadirás una interfaz de blueprint y un requisito de llave a esta lógica para que la puerta no se abra a menos que el actor sea el jugador y tengas la llave adecuada. 

   Puedes utilizar Ctrl + F para buscar el nombre de un nodo. Haz clic en el resultado de búsqueda para ir directamente a él.

2. Desconecta el evento ActorBeginOverlap del nodo Door Control manteniendo pulsada la tecla Alt y haciendo clic en el cable que une los dos nodos. Mueve el nodo de evento hacia atrás para tener espacio para más acciones de nodo antes de Door Control.

   Desconectar nodos de blueprint

3. Desde el nodo Event ActorBeginOverlap, arrastra su pin y añade un nodo Set Other Actor. Conecta el pin Other actor del nodo Event con el pin Other actor del nodo Set.

   

   Esto almacena el actor que se solapa con la zona de la puerta.

4. En el nodo Set Other actor, arrastra el pin azul de valor y crea un nodo Does Object Implement Interface. Establece el valor de Interface en BPI_PlayerKeys.

   

5. Desde el nodo Set Other actor, arrastra el pin de ejecución y crea un nuevo nodo Branch. 

Para comprobar que la puerta utiliza llaves, sigue estos pasos:

1. Arrastra el pin True del nodo Branch y crea un nodo Fn Has Key, que es la función que has creado anteriormente en este tutorial. Se necesita el tipo de llave necesario para abrir la puerta y se comprueba si se tiene ese tipo de llave en la matriz Held Keys del jugador. Llamar a esta función aquí ejecutará los nodos que contiene. 

2. Desde el nodo Fn Has Key, arrastra el pin de Ejecución y crea un nuevo nodo Branch. 

3. Conecta el pin Key Found del nodo Fn Has Key al pin Condition del nodo Branch.

4. Conecta el pin True del nuevo nodo Branch al pin Play del nodo Door Control.

   

Hasta ahora, esta lógica solo permite que la puerta se abra cuando el jugador tiene la llave correcta. La puerta también debería abrirse cuando:

• La puerta no necesita llaves, o

• un personaje no jugable intenta atravesar la puerta.

El primer nodo Branch y el nodo And prueban ambas condiciones. Si cualquiera de los dos valores es false, Branch también será false. 

Para garantizar de que la puerta se abre para los PNJ y cuando no se necesiten las llaves, sigue estos pasos:

1. Conecta el pin False del primer nodo Branch directamente al pin Play del nodo Door Control . Puedes utilizar conectores haciendo doble clic en un cable entre dos nodos para organizar tu blueprint.

   

2. Compila y guarda el blueprint.

Ahora, cuando el actor no implemente la interfaz de llave o la puerta no requiera llaves (UseKeys = False), la puerta se abrirá de todos modos.

La nueva lógica del grafo de eventos BP_DoorFrame debería tener el siguiente aspecto:

Añadir comentarios a un blueprint

Puedes añadir bloques de comentarios a tus blueprints para crear notas solo visuales que agrupen nodos y expliquen para qué sirve cada parte del blueprint. Los comentarios te ayudan a ti y a los miembros de tu equipo a saber de un vistazo qué función están realizando tus nodos y a mantener los blueprints organizados.

Al compilar la lógica de blueprint, céntrate primero en crear las funciones y luego resalta los nodos que has añadido y añade un comentario que los contenga y describa.

Para añadir un comentario a un blueprint, sigue estos pasos:

1. Haz clic en el grafo para asegurarte de que es el panel activo.

2. Pulsa la tecla C del teclado. Esto añade un cuadro de comentarios.

3. Haz doble clic en el campo de texto de la parte superior del cuadro para introducir un comentario.

4. Para cambiar el tamaño del comentario, asegúrate que el comentario esté seleccionado (resaltado con un contorno amarillo) y arrastra un borde o una esquina.

5. Para agrupar nodos dentro de un comentario, arrastra esos nodos dentro de los límites del comentario.

También puedes seleccionar uno o varios nodos y pulsar C para añadir un comentario que contenga los nodos seleccionados. 

Probar tus puertas

Vuelve a tu nivel en el editor de niveles. Usa la propiedad Required Key de tus puertas para establecerlas con distintos colores y añadir una BP_Key para cada color.

Ahora, juega al juego. Si te acercas a la puerta sin coger la llave, la puerta no se abrirá.

Sin embargo, si coges la llave, la puerta se abrirá cuando te acerques a ella. Cuando te alejes lo suficiente, se cerrará automáticamente. 

Después de recoger una llave de un color, intenta abrir una puerta de otro color. La puerta debería permanecer cerrada.

Si estás trabajando con el nivel de muestra de este tutorial, selecciona la puerta que conduce al pasillo 2 y cambia la llave requerida a la llave azul. A continuación, selecciona la puerta que conduce al pasillo 3 y cambia la llave requerida a la llave roja. Haz que para la puerta del pasillo 1 sea la amarilla.

Añadir comentarios con mensajes de depuración

Si quieres comprobar lo que ocurre en un blueprint durante la jugabilidad, puedes usar nodos Print String para mostrar mensajes en pantalla. Unreal Engine no muestra estos mensajes en el juego final.

Prueba a añadir un nodo Print String para confirmar el tipo de llave que ha cogido el jugador.

Para mostrar un mensaje de depuración con nodos Print String, sigue estos pasos:

1. En el Event Graph BP_AdventureCharacter, dirígete al conjunto de nodos que empieza por Event fnBPIAddKey y añade llaves a la matriz HeldKeys.

2. Arrastra desde el pin de ejecución del nodo Add y añade un nodo Print String.

3. La In String es el texto que aparece en pantalla. Introduce el texto personalizado o conecta el pin Key Type del nodo Event a In String. Esto muestra la llave que está recogiendo el jugador.

   

4. Compila el blueprint.

5. Vuelve a reproducir tu juego y recoge las llaves. Verás el texto de depuración que confirma cada color de llave a medida que los vas recogiendo. 

6. Cuando hayas terminado, vuelve al grafo de nodos y elimina los nodos Print String y Enum to String. Compila y guarda el blueprint.

Si algo no funciona como se espera en un blueprint, puedes añadir nodos de Print String después de los cálculos, llamadas a evento o llamadas a función para ayudar a rastrear lo que está sucediendo con los valores y el flujo.

Colocar objetos que se pueden recoger

Hasta ahora, has estado colocando llaves en el suelo. Para que resulte más interesante y entretenido para el jugador, introduce un elemento de plataformas. 

En el nivel de muestra de este tutorial, añadimos algo de verticalidad colocando la llave en un lugar alto para que el jugador tuviera que saltar hasta la llave. En este caso, existe un riesgo menor de caerte y tener que empezar de cero.

El jugador practica saltando en la primera y la segunda plataforma antes de ponerse a prueba con el salto final al pilar, que es más complicado.

Prueba el nivel de muestra

Si prefieres añadir los nuevos contenidos de la habitación diseñados en esta parte de la serie de tutoriales en lugar de crear los tuyos propios, copia los fragmentos de abajo.

Esbozo de la sala inicial

Este fragmento de texto contiene la rampa, el hueco retraído, el pilar y las dos mallas de la plataforma añadidas para crear la ruta hasta la llave amarilla.

Begin Map
   Begin Level
      Begin Actor Class=/Script/Engine.StaticMeshActor Name=Floor_168 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168'"
         Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
         End Object
         Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.Floor_168.StaticMeshComponent0'"
            StaticMesh="/Script/Engine.StaticMesh'/Engine/MapTemplates/SM_Template_Map_Floor.SM_Template_Map_Floor'"
            bUseDefaultCollision=False
            StaticMeshDerivedDataKey="STATICMESH_34081786561B425A9523C94540EA599D_359a029847e84730ba516769d0f19427Simplygon_5_5_2156_18f808c3cf724e5a994f57de5c83cc4b_680318F3495BDBDEBE4C11B39CD497CE000000000100000001000000000000000000803F0000803F00000000000000000000344203030300000000"
            MaterialStreamingRelativeBoxes(0)=4294901760

Para colocar nuevas formas de esbozo en la sala inicial, sigue los siguientes pasos:

• En Unreal Editor, elimina todas las llaves de la sala inicial para que no se pierdan en la nueva geometría.

• Haz clic en Copiar todo el fragmento.

• En Unreal Editor, asegúrate de que el visor es el panel activo (haz clic en cualquier parte del visor o del esquematizador y pulsa Esc) y, a continuación, pulsa Ctrl + V.

  Si has movido alguna de las salas de esbozo de la parte anterior de este tutorial, es posible que las nuevas mallas no aparezcan en el lugar correcto. Desplázalas según sea necesario.

• Tres contenidos de suelo cubren el nuevo suelo retraído. En el visor, haz clic en cada uno de ellos y pulsa Supr.

  

Siguiente

Tu personaje jugable puede recoger llaves, pero no hay feedback para indicarle qué ha cogido hasta ahora. En la siguiente sección, crearás una interfaz de juego (HUD) para el jugador que le mostrará las llaves de su inventario.

• 

  HUD del jugador

  Crea una visualización frontal (HUD) sencilla que se actualice cuando el jugador recoja un objeto.