Cómo crear una llave

En esta sección, crearás tu primer objeto de jugabilidad: un blueprint de llave.

Para crear la función de los objetos de jugabilidad en el nivel, utilizarás secuenciación de comandos visual de Blueprint. En Unreal Engine, los blueprints son recursos con una representación física y una función especial, como que el jugador pueda cogerlos.

El sistema de secuenciación de comandos visual de Blueprint puede utilizarse para crear funciones sin tener que escribir código, como si estuvieras usando una interfaz basada en nodos para crear el comportamiento de un objeto de jugabilidad.

Primero, definirás el actor de la llave en el juego, añadiendo componentes que te permitan configurar llaves para que aparezcan en tres variaciones diferentes: un óvalo amarillo, un rectángulo azul o un cono rojo. En lugar de crear recursos por separado para cada variación, los blueprints te permiten compilar todas estas opciones en un solo recurso.

A continuación, añadirás el comportamiento de la llave: la capacidad del personaje jugable para recogerla. Recoger objetos es una de las mecánicas de jugabilidad más comunes.

Aquí tienes un resumen de todos los recursos que deberás crear para generar una llave con tres opciones de apariencia diferentes y permitir que un personaje jugable la recoja:

Antes de empezar

Asegúrate de que comprendes los siguientes temas, ya tratados en secciones anteriores de El diseño de una aventura de puzles:

• La IU de Unreal Editor, como el explorador de contenido y el visor.

• Conocimientos de blueprints. Consulta la documentación Blueprint Foundations (fundamentos de Blueprint) si quieres más información.

Necesitarás los siguientes recursos de Configuración del proyecto y esbozo de nivel:

• Un nivel con habitaciones bloqueadas.

Define tipos y atributos de llaves

Antes de crear el blueprint de llave, definirás algunos datos de llave que utilizará el blueprint para crear las variaciones roja, amarilla y azul.

Para representar los distintos tipos de llaves que se utilizarán en tu juego, usarás tanto una enumeración como una estructura.

Cada enumerador actúa como una etiqueta en un contenedor, y el struct es como el contenido de cada contenedor.

Definir tipos de llave en una enumeración

Primero, crea un recurso de enumeración que defina tus variantes de llave: roja, amarilla y azul.  

Para crear un recurso de enumeración, sigue estos pasos:

1. Abre el explorador de contenido o un almacén de contenido, utilizando el botón Almacén de contenido en la esquina inferior izquierda de Unreal Engine.

2. Crea un lugar para almacenar los blueprints y los recursos de apoyo que crearás en este tutorial. Ve a la carpeta Contenido > AdventureGame > Designer. Haz clic derecho en esta carpeta y haz clic en Nueva carpeta.

3. Llama a la nueva carpeta Blueprints.

4. En la carpeta Blueprints , crea otra carpeta llamada Core.

5. Haz clic derecho en la carpeta Core , ve a Blueprint y haz clic en Enumeración desde el menú Crear recurso. Llama al nuevo recurso Enum_KeyType.

   

6. Haz doble clic en el recurso para abrirlo en una ventana nueva.

La enumeración contiene una lista de opciones de enumerador. 

Para añadir tipos de llave a la enumeración, sigue estos pasos:

1. Haz clic tres veces en el botón Añadir enumerador para añadir tres nuevas enums a la lista.

2. Cambia el nombre en pantalla del primer enumerador a Azul. Cambia el segundo a Amarillo y el tercero a Rojo.

   

3. Guarda el archivo de recurso de enumeración haciendo clic en el botón Guardar en la esquina superior izquierda de la ventana. También puedes utilizar CTRL + S. 

Cuando añades un enumerador, estás añadiendo una opción a la lista. Azul, amarillo y rojo son valores que utilizarás para distinguir entre los distintos tipos de llave.

A diferencia de los blueprints, no es necesario compilar recursos de datos , puesto que no estás compilando ninguna función. 

Define atributos de llave en un struct

A continuación, crea un struct que defina los atributos que distinguen cada tipo de llave: una forma de malla y un color.

Para compilar un recurso de estructura (struct), sigue estos pasos:

1. Vuelve al explorador de contenido y asegúrate de que sigues en la carpeta Contenido > AdventureGame > Designer > Core.

2. Haz clic derecho en cualquier parte de la carpeta Core , ve a Blueprint y haz clic en Estructura. Llama a este recurso Struct_KeyData.

   

3. Haz doble clic en el nuevo recurso para abrirlo en una nueva ventana con las propiedades del struct.

4. El struct tendrá una variable por defecto, llamada MemberVar_0. Haz clic en Añadir variable para añadir una segunda variable.

5. Cambia el nombre de la primera variable a Material de llave y el de la segunda a Malla de llave.

6. Cada variable tiene un tipo de datos asignado. Esto viene establecido en booleano (un valor de verdadero o falso) por defecto. Tienes que cambiar el tipo de ambas variables.

   Para la variable Material de llave, haz clic en el desplegable que dice Booleano. Escribe Material instance en el campo de búsqueda, sitúa el cursor sobre Material Instance y selecciona Referencia a objeto. 

   

7. Repite estos pasos para cambiar el tipo de variable de Malla de llave a Static Mesh > Referencia a objeto. 

   

8. Guarda el archivo de recurso del struct. 

Ya has creado dos atributos que usará cada tipo de llave: un material de llave que establecerá el color de la llave y una malla de llave que establecerá la forma de la llave. 

Ya has terminado de definir el tipo de datos que tiene la llave. A continuación, configurarás los colores de las llaves y construirás de verdad cada tipo de llave.

Crear colores de llave 

Ahora que tienes los datos para los tipos de llave azul, amarilla y roja, crearás materiales con los colores correspondientes que asignarás a cada tipo de llave.

En Unreal Engine, un material define el aspecto de una superficie. Controla aspectos como el color, la textura, el brillo, la transparencia y muchos más. Una instancia de material es una copia de un material que utiliza el material como base, pero puede anular ajustes específicos como colores o texturas, sin necesidad de crear un material nuevo desde cero.

En este ejemplo, crearás un material base que define los atributos de todas las llaves del juego. Después, crearás dos instancias de material de ese material para copiar todos los atributos, pero anular los colores.

Para crear un recurso de material coloreado, sigue estos pasos:

1. Ve al explorador de contenido. Ve a la carpeta Content > AdventureGame > Designer.

2. Haz clic derecho en la carpeta Designer y haz clic en Nueva carpeta. Dale a esta carpeta el nombre Materiales.

3. Ve a la carpeta Materiales . Haz clic derecho en la carpeta y selecciona Material para crear un recurso de material.

   

4. Cambia el nombre del recurso de material a M_BasicColor.

   El nivel de muestra del tutorial usa el prefijo M_ como convención de nomenclatura para identificar materiales.

5. Haz doble clic en el material para abrirlo. Esto abrirá el editor de materiales en una nueva ventana.

El editor de materiales es un editor basado en nodos, lo que significa que se ha diseñado de forma similar a la secuenciación de comandos visual de Blueprint. Deberías ver un nodo llamado M_BasicColor, que es el nodo principal que puedes utilizar para cambiar las propiedades de este material.

La propiedad Color base establece el color de este material. Puedes hacer clic en la muestra de color gris que hay junto a Color base para establecer el color manualmente. 

En lugar de usar el selector de color, crearás un nodo de parámetro Color que puedes anular en cada instancia de material y, por lo tanto, crearás un material que puede tener muchos colores. Crear un parámetro es como añadir una variable: convierte el color del material en un parámetro editable en una instancia de material.

Para crear un nodo de parámetro de color, sigue estos pasos:

1. Junto a Color base, verás un pin. Haz clic en el pin y arrástralo a un área vacía del grafo. 

   

2. En la lista desplegable, escribe VectorParameter en el campo de búsqueda y selecciona VectorParameter.

   Como resultado, se creará un nuevo nodo con un selector de color. Una variable de tipo vectorial tiene tres valores, por lo que puedes utilizarla para definir los valores RGB de un color.

3. El nombre del nodo por defecto, Param, aparece resaltado cuando creas el nodo por primera vez. Cambia el nombre del nodo por Color para que sea más fácil de identificar en tus instancias de material.

   Si la opción Param no está resaltada, haz clic en el nodo y luego en el nombre del nodo para cambiar el nombre.

4. En el nuevo nodo Color , haz clic en el cuadrado a cuadros que hay junto a Default Value para abrir un selector de color.

   

5. En el campo Hexadecimal sRGB, cambia el valor a F7DE0000, un color amarillo, y haz clic en aceptar. 

   

6. Guarda y cierra el recurso material.

A continuación, crearás instancias de material para añadir más colores sin tener que recrear el material principal. 

Para crear tres instancias de material para los colores de llave, sigue estos pasos:

1. En el explorador de contenido, haz clic derecho en el recurso M_BasicColor que has creado. Cerca de la parte superior del menú contextual, haz clic en Crear instancia de material.

2. Llama al recurso de instancia de material M_BasicColor_Red. Haz doble clic en el recurso para abrirlo.

   

   Te darás cuenta de que esta ventana es diferente de la del editor de materiales. Esto se debe a que una instancia de material no necesita el conjunto de edición completo de un material , sino que se centra en modificar los parámetros que definiste en el material base.

3. En el panel de detalles , debajo de los grupos de parámetros en la parte superior, expande Global Vector Parameter Values.

   

4. Verás un Color deshabilitado, que es el nodo VectorParameter que has añadido al material base. Haz clic en la casilla de verificación junto a Color para activarlo y anularlo.

   

5. Haz clic en la muestra de color que hay junto a Color y fija el valor Hexadecimal sRGB en F7005A00. Esto cambiará la instancia de material a un precioso color rojo vivo.

6. ¡Ahora te toca a ti dirigir! Repite este proceso para crear dos instancias de material más: 

   1. Crea una instancia de material llamada M_BasicColor_Blue. Anula el color con Hexadecimal sRGB = 00AFF700 y guarda el recurso. 

   2. Crea una instancia de material llamada M_BasicColor_Yellow. Mantén el color del material base y guarda el recurso.  

Compila el blueprint de llave

Ahora que tienes todas las piezas que necesitas, es hora de crear el blueprint de llave. El blueprint de llave es el recurso que puedes añadir a un nivel para crear un actor instanciado a partir de él, con la función de que el jugador puede recogerlo.

Para crear una nueva clase de blueprint para la llave, sigue estos pasos:

1. Ve al explorador de contenido y navega hasta la carpeta Contenido > AdventureGame > Designer > Blueprints.

2. Crea una carpeta nueva llamada Llave.

3. Ve a la carpeta Llave. Haz clic con el botón derecho en la carpeta y selecciona Clase de Blueprint.

4. Selecciona Actor como clase padre.

   

5. Llama a este nuevo actor BP_Key y haz doble clic para abrirlo.

   El nivel de muestra del tutorial usa el prefijo BP_ como convención de nomenclatura para identificar las clases de blueprint.

La clase padre Actor se suele utilizar para un objeto que se puede colocar en un nivel; no tiene funciones adicionales como movimiento, como en la clase padre personaje, pero se puede usar para compilar interacciones y lógica.

Hay que añadir algunas cosas a nuestro blueprint de llave para que funcione correctamente:

1. Una malla estática para representar visualmente la llave en el proyecto.

2. Un volumen de colisión que detecta cuándo el jugador está lo bastante cerca como para recoger la llave.

3. Una forma de saber de qué tipo de llave se trata.

4. Lógica del juego para determinar qué ocurre cuando el jugador colisiona con la llave.

Configurar los componentes de la llave 

Primero, configura los componentes de la llave para tener algo con qué colocar e interactuar en el mundo del juego.

Para añadir un componente de colisión y una forma de malla a la llave, sigue estos pasos:

1. En BP_Key, ve a la pestaña Visor.

2. En la esquina superior izquierda del panel Componentes, haz clic en Añadir y busca y selecciona Capsule Collision.

   

   Es el volumen de colisión que puede tocar el jugador para coger la llave. Sin esto, el jugador no podría detectar la llave. 

   Podrías añadir colisión a la propia malla de llave, pero utilizar una forma de colisión ayuda a equilibrar geometrías complejas, lo que mejora la detección de colisiones y el rendimiento del juego. 

3. Selecciona el componente Capsule y haz clic en Añadir de nuevo. Esta vez, busca y selecciona una forma básica Esfera y cámbiale el nombre KeyMesh. 

   Al seleccionar el componente Capsule y añadir la malla Esfera, la malla se convierte en un hijo de Capsule, y Capsule, a su vez, se convierte en el padre de la malla. El componente hijo hereda todas las propiedades del padre. 

4. Configura el componente KeyMesh :

   1. Selecciona el componente KeyMesh . En el panel de detalles , ve a la categoría Transformar. Junto a Escalar, cambia los valores a 0.3, 0.3 y 1.0. 

      

      Esto encoge los laterales de la malla para que adopte una forma ovalada.

   2. En la categoría Colisión , configura Preajustes de colisiónen NoCollision.

      

      Has añadido la colisión al componente de cápsula para desactivar la colisión en la malla, lo que garantiza que el personaje jugable pueda recoger la llave sin problemas y sin rebotar en la malla estática.

5. Configura el componente Capsule:

   • Selecciona el componente Capsule . En el panel Detalles , en la categoría Transformar, establece Ubicación en 0.0, 0.0, 80.0.

     Esto hace que la llave flote sobre el suelo. La malla se mueve con la cápsula porque la malla es un componente hijo que hereda todas las propiedades de su componente padre.

   • En la categoría Forma , establece Capsule Half Height en 60.0. Esto amplía el volumen de colisión para que envuelva mejor la malla.  

6. En el panel Componentes, selecciona DefaultSceneRoot. Haz clic en Añadir y selecciona Rotating Movement. Esto hará que la llave sea más interesante para el jugador.

   

7. Guarda y compila el blueprint.

Configurar las propiedades de la llave

Tu llave también necesita almacenar información, como qué tipo de llave es y qué materiales y mallas corresponden a cada tipo de llave. 

Para establecer esto, usarás la enumeración Key Type y el struct Key Data que has creado antes. 

Para añadir una variable de tipo de llave al blueprint, sigue estos pasos:

1. En el panel Componentes, verás el panel Mi Blueprint. En la sección Variables , haz clic en el botón del signo más (+) para añadir una nueva variable.

2. Asigna a la variable el nombre KeyType.

3. Por defecto, su tipo es booleano. Haz clic en el desplegable de tipo, busca Enum Key Type y selecciónalo. Este tipo de variable es la enumeración que has creado antes, así que es hora de utilizarla. En este caso, significa que la variable KeyType se puede establecer en rojo, amarillo o azul.

   En los blueprints, el tipo de variable también se denomina tipo de pin, ya que las variables aparecen como pines en los nodos.

4. Haz clic en el ojo que hay junto a la variable KeyType para que sea pública y editable. Esto es importante para que más adelante puedas editar el valor de esta variable en el Unreal Editor y establecer el tipo de cada llave en tu nivel.

   

5. Haz clic en KeyType para seleccionarlo. En el panel Detalles, junto a la propiedad Categoría, elimina Predeterminado y escribe Setup.

   Esto hace que la propiedad KeyType aparezca en el panel de detalles en una categoría llamada Configuración.

   

Cada tipo de llave debe tener una forma y una combinación de colores. En el siguiente paso, crearás una variable de mapa para definir estas combinaciones.

Para configurar una variable que asigne tipos de llave a formas y colores, sigue estos pasos:

1. En el panel Mi blueprint, añade una nueva variable llamada KeyMap, también de tipo Enum Key Type.

2. Con la variable KeyMap seleccionada, en el panel Detalles, junto al desplegable de tipo, hay otro menú que establece el tipo de contenedor de la variable o cuántos valores contiene la variable. Cambia el tipo de contenedor a Mapa.

   

3. Cuando estableces el contenedor en Mapa , aparece otro desplegable de tipo junto al tipo de contenedor. Este es el tipo de datos almacenados en cada opción de mapa. Ya definiste estos datos de llave antes en un struct, así que haz clic en el desplegable y establece que el tipo de datos sea Struct_KeyData.

4. Compila el blueprint para poder propagar el KeyMap con materiales y formas de malla, estableciendo un par material-malla para cada opción de KeyType.

5. En el panel de detalles , ve a la categoría valor por defecto.

6. Junto a Key Map, haz clic en el botón + para añadir un nuevo elemento al mapa.

7. Cambia el Key Type de Azul a un color diferente. Si no lo haces, es posible que no puedas añadir un nuevo elemento porque ya existe un elemento con el tipo de llave por defecto.

8. Repite esto dos veces más para crear un segundo y un tercer elemento.

9. Una vez añadidos los tres elementos del mapa, configura los tipos de llave en los siguientes valores:

   Key Type	Material de llave	Malla de llave
   Rojo	M_BasicColor_Red	Cono
   Amarillo	M_BasicColor_Yellow	Sphere (esfera)
   Azul	M_BasicColor_Blue	Cubo

   Hay varias mallas llamadas Cube y Sphere en el proyecto. Las mallas Cube y Sphere correctas deberían aparecer en segundo lugar de la lista cuando las busques. Cuando pases el cursor sobre ellos, deberían incluir una ruta /Engine/BasicShapes en la burbuja informativa. 

   

   Ahora tu KeyMap debería tener el siguiente aspecto: 

   

10. Guarda y compila el blueprint. 

Por último, necesitas una variable que almacene una referencia al personaje jugable cuando toque la llave. 

Para crear una variable que almacene una referencia a otro actor, sigue estos pasos:

1. En la sección Variables, añade una nueva variable llamada OtherActor.

2. Cambia su tipo a Actor > Referencia a objeto.

3. En el panel de detalles , cambia su tipo de contenedor a Única, ya que solo necesitas referenciar un actor que interactúe con esta llave: el jugador.

Ahora, las variables de la llave deberían tener el siguiente aspecto:

Probar la llave

Prueba la llave para ver qué aspecto tiene de momento. 

Vuelve a tu nivel y, en el explorador de contenido, arrastra BP_Key al nivel. Has creado un blueprint desde el que puedes añadir instancias a tu juego, ¡y merece la pena celebrarlo! Sin embargo, sigue siendo gris.

Con la llave seleccionada, ve al panel Detalles . Busca la categoría Configuración que has creado y busca la propiedad Key Type. Puedes cambiar esto de azul a amarillo y luego a rojo, pero todavía no cambiará tu llave ovalada gris. 

Esto se debe a que has añadido componentes y datos a la llave, pero esas partes aún no se comunican entre sí. Aquí es donde entra en juego la secuenciación de comandos visual de Blueprint: compilarás lógica (nodos y cables) para transmitir información por un blueprint y realizar acciones con esa información.

Establecer valores de llave con una función de blueprint

A continuación, crearás una función que conectará las opciones del KeyMap con el componente KeyMesh y ajustará automáticamente la forma de malla y el color de material correctos para una llave en función de su tipo.

En lugar de crear la función en el blueprint de llave, la colocarás en una nueva biblioteca de funciones de blueprint, que es un tipo de recurso de blueprint que almacena una colección de funciones reutilizables. Estas funciones no están vinculadas a un blueprint o actor específico. En su lugar, son accesibles globalmente desde todo tu proyecto. Las bibliotecas mantienen funciones útiles en un solo lugar para que no tengas que copiarlas y pegarlas en múltiples blueprints.

Para crear una biblioteca de funciones de blueprint con una nueva función, sigue estos pasos:

1. Ve al explorador de contenido y accede a Contenido > AdventureGame > Designer > Core.

2. Haz clic derecho en la carpeta Core , ve a Blueprint y selecciona Biblioteca de funciones de Blueprint. Llama al nuevo recurso BPL_FPGame y ábrelo.

   

3. En el panel Mi Blueprint, en la sección Funciones, empiezas con una nueva función resaltada. Llámala fnBPLSetKey.

   

   El proyecto de muestra del tutorial usa la etiqueta BPL para las funciones de una biblioteca de blueprints y un prefijo fn para las funciones. Esto ayuda a identificar qué SetKey es y de dónde proviene, y hace que sea más sencillo encontrar la función en la lista de acciones del nodo.

A continuación, configura la función con las entradas y salidas que necesita. 

Las entradas son valores que pasas a una función para que pueda hacer su trabajo. Actúan de forma similar a las variables. La función fnBPLSetKey necesita realizar acciones entre KeyType, KeyMap y KeyMesh, por lo que estas deberían ser entradas.

Las salidas son información que la función devuelve al blueprint, normalmente después de generar un resultado. La función fnBPLSetKey no necesita ninguna salida. 

Para añadir entradas a la función fnBPLSetKey , sigue estos pasos:

1. Haz clic en la función fnBPLSetKey para seleccionarla. En el panel Detalles, junto a la categoría Entradas, haz clic en el botón + para crear una nueva entrada.

   Al igual que las variables, cada entrada tiene un nombre, un tipo de pin de variable y un tipo de contenedor.

2. Cambia el nombre de la entrada a Matriz de mallas estáticas.

3. Cambia su tipo a un Static Mesh Component > Referencia a objeto. En el grafo de nodo de la función, fíjate en cómo el nodo morado de entrada de la función ahora tiene un pin con la entrada que has creado, y el estilo del pin refleja el tipo (matriz de mallas estáticas).

4. Haz clic en el desplegable de tipo de contenedor que hay junto al tipo y selecciona Matriz.

   

   Una matriz es una variable que almacena múltiples valores del mismo tipo en un solo contenedor. Cada valor se almacena como un elemento de matriz.

5. Configura otra entrada para que se corresponda con la propiedad KeyMap de la llave:

   1. Añade otra entrada y llámala KeyMap.

   2. Haz clic en el desplegable de tipo de pin y elige Enum Key Type.

   3. Haz clic en el desplegable de tipo de contenedor y selecciona Mapa.

   4. Haz clic en el desplegable de tipo de valor y establécelo en Struct Key Data.

6. Configura una entrada de tipo de llave:

   1. Añade otra entrada llamada Llave.

   2. Establece que su contenedor sea Única y que su tipo sea Enum Key Type.

Ahora, tus tres entradas deberían tener este aspecto:

Ahora, puedes compilar los nodos de la función. En el panel de grafo, puedes ver el nodo de entrada de función fnBPLSetKey con las entradas que acabas de crear: Matriz de mallas estáticas, Key Map y Llave.

Para añadir lógica a la función que configure las llaves con una nueva forma de malla de llave, sigue estos pasos:

1. Arrastra desde el pin de ejecución (Excec) en forma de triángulo de este nodo, busca For Each Loop en la lista de acciones del nodo y selecciónalo. Esto crea un nuevo nodo conectado al nodo fnBPLSetKey.

   Con el nodo For Each Loop, puedes realizar algunas acciones en cada elemento de una matriz. Cualquier lógica que conectes al pin de ejecución del cuerpo del bucle se ejecuta una vez por cada elemento de la matriz. Cuando el bucle termina, la ejecución continúa hasta el pin Completed.

   

2. Arrastra el pin Matriz de mallas estáticas del nodo fnBPLSetKey y conéctalo al pin Array de For Each Loop.

   

   La llave solo tiene una malla, pero fnBPLSetKey usa una matriz de mallas estáticas para que puedas utilizarla con diversos objetos de nivel. Por ejemplo, en la siguiente parte de esta serie de tutoriales, trabajarás con el blueprint de puerta que tiene dos mallas estáticas una para la puerta derecha y otra para la puerta izquierda.

3. A continuación, arrastra el pin Key Map del nodo fnBPLSetKey y busca y selecciona un nodo Find. Este nodo puede tomar un tipo de llave y extraer la malla y el material correspondientes de KeyMap.

4. Haz clic derecho en el pin de salida Azul del nodo Find y clic Dividir pin de estructura. 

   

   Esto divide la salida en Material de llave y Malla de llave, que son las dos variables de Struct_KeyData.

5. Conecta el pin Llave del nodo fnBPLSetKey con el pin turquesa llave del nodo Find. 

   

6. Ahora, en el nodo For Each Loop, arrastra desde el pin Loop Body y busca Is Valid en la categoría Estructura. Añade el nodo Is Valid que tiene un icono de signo de interrogación (?) junto a él, ya que este es el nodo que se utiliza para los valores de struct. 

   

   Este nodo comprueba si se ha pasado una forma de malla válida a la función. Si es así, establecerás tanto la malla estática del objeto como su material. De lo contrario, solo establecerá el material. 

7. Conecta el pin Malla de llave del nodo Find con el pin Input Object del nodo Is Valid. 

   

8. En el nodo Is Valid, arrastra el pin Is Valid y cambia la opción Sensible al contexto a falso.

   

9. Busca y añade un nodo Set Static Mesh.

10. En el nodo For Each Loop, arrastra el pin Array Element y conéctalo al pin Target del nodo Set Static Mesh.

    Target es la entidad sobre la que actuará el nodo. Te interesa establecer la acción de Set Static Mesh en KeyMesh, por lo que el objetivo debería ser la matriz de mallas estáticas.

11. En el nodo Find , arrastra el pin Malla de llave y conéctalo al pin New Mesh del nodo Set Static Mesh. 

El grafo de la función quedaría así:

Puedes hacer doble clic en un cable entre dos nodos para crear un conector adicional. Mueve el cursor sobre el conector hasta que el cursor se convierta en cuatro flechas y luego arrastra el conector para cambiar la forma de los cables. Esto puede ayudarte a colocar los nodos y las líneas con total libertad.

Selecciona un cable y pulsa la tecla Q para enderezar un cable.

Ya has establecido la nueva forma de malla en la llave, así que solo te queda establecer también el nuevo material.

Para añadir una lógica que configure las llaves con un nuevo color de material de llave, sigue estos pasos:

1. Arrastra el pin Ejecución del nodo Set Static Mesh y busca el nodo Set Material (en la categoría Renderizado> Material) y créalo.

2. Arrastra su pin Target hasta el elemento Array Element del nodo For Each Loop.

3. Arrastra su pin Material hasta el pin Material de llave del nodo Find.

   

4. Para asegurarte de que el material se establece cuando no se proporciona una malla, conecta el pin Is Not Valid del nodo al pin de ejecución del nodo Set Material. Añade dos conectores para remodelar el cable.

5. Guarda y compila el blueprint.

Tu función fnBPLSetKey al completo debería quedar así:

Inicializar las llaves

Ya puedes usar las función que has creado dentro del blueprint de llaves. Primero, inicializarás la llave en función del KeyType que le asignes. 

Para inicializar la llave, sigue estos pasos:

1. Arrastra el pin Exec del nodo Construction Script y busca la función fnBPLSetKey, que has creado antes.

   

   El nodo de función necesita una matriz de mallas estáticas, un mapa de llave y un identificador, que proporcionarás en BP_Key.

2. En el panel Mi Blueprint, en la sección Variables, expande la categoría Configuración y arrastra la variable KeyType al grafo de nodo, cerca del nodo de función. 

   

3. Esto te preguntará si quieres Obtener o Establecer el valor de la variable. En este caso, tienes que comprobar de qué tipo de llave se trata, así que selecciona Obtener. 

4. Conecta el pin del nuevo nodo Get Key Type al pin Llave del nodo Fn BPLSet Key.

   

5. Repite el mismo proceso con la variable KeyMap. Arrástrala al grafo de nodo y crea un nodo Obtener. Conecta el pin de este nodo al pin del KeyMap del nodo Fn BPLSet Key.

   

6. A continuación, desde el panel Componentes, arrastra KeyMesh al grafo y crea un nodo Get. 

7. El nodo Key Mesh contiene una sola referencia de componente de malla estática, pero el nodo de función necesita una matriz. Unreal Engine puede encargarse de esto por ti: conecta el pin Key Mesh al pin Matriz de mallas estáticas del nodo Fn BPLSet Key.

8. Guarda y compila tu blueprint.

  La secuencia de comandos de construcción de la llave debería tener ahora el siguiente aspecto: 

Prueba la función de la llave

Ahora, puedes probar la función de cambio de color que has creado en la llave y en la nueva función. 

Cierra la ventana del editor de blueprints y vuelve al editor de niveles.  

Dado que el valor predeterminado del tipo de llave es Azul, tu llave debería inicializarse como un rectángulo azul. 

Selecciona el actor llave y, en el panel de detalles , en la sección Configuración , cambia el tipo de llave entre Amarillo y Rojo. A medida que cambies, deberías ver cómo cambia el color y la forma de la llave en el nivel.

Si la llave rectangular y la ovalada te parecen demasiado grandes, puede que hayas seleccionado los recursos de malla equivocados al crear el KeyMap. Vuelve a los detalles de tu KeyMap y asegúrate de que las mallas de esfera y cubo son de la ruta /Engine/BasicShapes.

Conceder llaves al personaje jugable

Tu jugador necesita una forma de recoger llaves y que otros objetos sepan qué llaves tiene el jugador. Para gestionar la concesión y recuperación de llaves, utilizarás una interfaz de Blueprint.

Utilizar una interfaz de blueprint para comunicar entre blueprints 

Una interfaz de Blueprint almacena una lista de funciones que puede usar cada blueprint que tenga acceso a la interfaz. Implementar una interfaz significa dotar a tu blueprint de la capacidad de responder a un conjunto compartido de eventos (o mensajes).

En un juego en el que los personajes jugables y los PNJ van de un lado a otro, la llave necesita un modo de asegurarse de que solo interactúa con el personaje jugable. Para ello, crearás una interfaz de Blueprint que implementar en BP_AdventureCharacter. Actúa como una hoja de permiso que el blueprint del jugador utiliza para recibir el mensaje de recoger la llave. 

Las interfaces de Blueprint son útiles cuando quieres que diferentes blueprints se comuniquen sin conocer los detalles unos de otros.

Para crear una interfaz de Blueprint con dos funciones, sigue estos pasos:

1. Desde el explorador de contenido, ve a Contenido > AdventureGame > Designer > Blueprints > Core.

2. Haz clic derecho en la carpeta Core , ve a Blueprint y crea una nueva Interfaz de Blueprint. Llama a este recurso BPI_PlayerKeys y ábrelo haciendo doble clic en él.

   Esta ventana tiene un aspecto similar al del editor de blueprints. A la derecha verás el panel Mi Blueprint, que enumera todas las funciones de esta interfaz. Debajo de él está el panel Detalles .

3. En el panel Mi Blueprint , ya hay una función inicial creada para ti. Llámala fnBPIAddKey.

4. Selecciona la función y, en el panel Detalles, en la sección Entradas, pulsa el botón + para añadir una nueva entrada.

5. Asigna a la entrada el nombre KeyType y cambia su tipo a Enum Key Type.

   

6. También en el panel Detalles, junto a Categoría, introduce Keys. Esto hace que tu función sea más fácil de encontrar en la lista de interfaces de los blueprints.

7. A continuación, añade una nueva función en el panel Mi Blueprint llamada fnBPIGetKeys, que se encargará de recuperar las llaves. 

   

8. Selecciona la nueva función fnBPIGetKeys y, en el panel Detalles, en la sección Salidas, haz clic en el botón + para añadir un nuevo parámetro nombrado Llaves que tienes. 

9. Cambia su tipo a Enum Key Type, y el valor de retorno a Matriz para que pueda devolver las llaves encontradas por el jugador. 

   

10. Guarda y compila tu interfaz. Ahora puede cerrar la ventana BPI_PlayerKeys.

    Dado que una interfaz está relacionada con el sistema de blueprints, es necesario compilarla tal y como haces con los blueprints.

Ten en cuenta que en la interfaz de Blueprint solo has creado declaraciones de función. Las funciones de interfaz no contienen lógica en sí mismas, pero su configuración determina cómo puedes utilizarlas en blueprints. 

Las funciones de interfaz sin salidas (fnBPIAddKeys) actúan como eventos, mientras que las funciones con salidas (fnBPIGetKeys) funcionan como funciones normales a las que puedes añadir lógica.

Crea un nuevo personaje jugable

Antes de añadir nada al personaje, tendrás que duplicar un personaje jugable por defecto que viene con el proyecto para crear tu propia variante. También tendrás que cambiar los ajustes del modo de juego para utilizar tu nuevo personaje.

Para crear un personaje jugable que utilizar en tu proyecto, sigue estos pasos:

1. Ve al explorador de contenido y navega hasta la carpeta Contenido > AdventureGame > Designer > Blueprints.

2. Crea una nueva carpeta llamada Personajes.

3. Ve a la carpeta Contenido > Variant_Shooter > Blueprints > FirstPerson.

4. Arrastra el recurso BP_ShooterChracter a la carpeta Personajes que has creado y selecciona Copiar aquí.

5. Haz clic derecho en la nueva copia de la carpeta Personajes para renombrarla BP_AdventureCharacter.

6. Ve a Editar > Configuración del proyecto. En el panel izquierdo, ve a los ajustes de Proyecto > Mapas y modos.

7. En el ajuste Modo de juego predeterminado, expande GameMode seleccionado.

   Un recurso modo de juego que define un conjunto de reglas para el mundo, incluido el personaje jugable por defecto. Tendrás que modificarlo para usar el nuevo personaje que has creado. Puedes cambiar los ajustes del modo de juego aquí o abriendo el propio recurso.

8. Cambia la opción Default Pawn Class a BP_AdventureCharacter.

   

9. Cierra la ventana Configuración del proyecto.

Para cambiar los ajustes del modo de juego por nivel en lugar de para todo el proyecto, usa Configuración del mundo. Esta pestaña se encuentra junto al panel de detalles.  

Si no ves el panel Configuración del mundo, en la barra del menú principal, ve a Ventanas y selecciona Configuración del mundo. 

Añadir la interfaz de Blueprint al jugador 

En esta sección, vas a modificar el blueprint del personaje jugable. Este personaje tiene muchas funciones e interfaces útiles ya configuradas para ti, y añadirás la interfaz BPI_PlayerKeys que has creado antes para que puedas recoger llaves.

A continuación, modificarás el nuevo BP_AdventureCharacter para que pueda utilizar llaves. 

Para añadir las funciones de la interfaz de Blueprint al personaje, sigue estos pasos:

1. Dirígete a tu nueva carpeta Characters y abre BP_AdventureCharacter.

2. Añadirás la interfaz BPI Player Keys para asegurarte de que el blueprint del jugador la implementa. En la barra de herramientas de la parte superior de la nueva ventana, haz clic en el botón Ajustes de clase.

3. En el panel Detalles de la derecha, en la sección Interfaces > Interfaces implementadas, haz clic en Añadir y selecciona BPI_PlayerKeys en el menú desplegable. Esto otorga a tu personaje la capacidad de implementar las funciones fnBPIGetKeys y fnBPIAddKey.

   

4. Compila el blueprint para poder usar las funciones de la interfaz. En la sección interfaces del panel Mi Blueprint , verás una categoría Llaves que contiene fnBPIAddKey y fnBPIGetKey. Tiene un icono amarillo en lugar de gris, lo que significa que estas funciones actúan como eventos. 

Guardar llaves recogidas 

El jugador necesita almacenar las llaves que ha recogido; para conseguirlo, crea una nueva variable. La variable debe contener hasta tres llaves, por lo que deberá ser una matriz.

Para crear una variable de matriz que almacene las llaves del jugador, sigue estos pasos:

1. En el blueprint BP_AdventureCharacter, añade una nueva variable a la lista Variables del panel Mi Blueprint.

2. Llama a la variable Llaves que tienes.

3. Selecciona la variable y, en el panel de detalles, establece que el contenedor sea una matriz del tipo Enum Key Type. Utilizar una matriz es importante, ya que el jugador puede tener varias llaves a la vez.

   

Para añadir llaves a la matriz Llaves que tienes cuando el jugador recoge una llave, sigue estos pasos:

1. Ve a la pestaña Event Graph del personaje.

2. Haz clic derecho en el grafo y busca el evento fnBPIAddKey. Este es el nodo de evento que se ejecuta cuando se llama a la función fnBPIAddKey.

3. Arrastra desde su pin de ejecución, busca Array Add, y selecciona un nodo Add. Este nodo toma un nuevo elemento y lo añade a una matriz.

4. Añade una referencia a la variable Llaves que tienes arrastrando la variable al grafo de eventos y selecciona Obtener.

5. Conecta el nodo Llaves que tienes con la entrada Target Array del nodo Array Add. Este pin tiene forma de cuadrado.

6. Conecta el pin Key Type del nodo Event con la entrada New Item del nodo Add.

   

Ahora, cuando esta función de evento se active, el personaje jugable añadirá el tipo de llave proporcionado a su matriz Llaves que tienes.

Recuperar la lista de llaves del jugador

La puerta con la que trabajarás en la siguiente parte de este tutorial tiene que comprobar todas las llaves del jugador, así que añade una función al jugador que devuelva una matriz de las llaves que ha cogido.

Para gestionar la recuperación de llaves, sigue estos pasos:

1. En el blueprint BP_AdventureCharacter , en Mi blueprint > Interfaces, expande la sección Llaves.

   

    En la lista, fnBPIGetKeys aparece con un icono gris, lo que significa que puedes utilizarla como una función normal y no como un evento.

2. Haz doble clic en fnBPIGetKeys para abrir el grafo de la función.

3. Añade una referencia a la variable Llaves que tienes arrastrándola y seleccionando Obtener.

4. Conecta el nodo Obtener llaves que tienes con el pin Llaves que tienes del nodo Return.

El grafo fnBPIGetKeys ahora debería tener el siguiente aspecto:

Hacer que las llaves detecten colisiones con el jugador

A continuación, añadirás una función que activará la función de evento fnBPIGetKeys cada vez que el jugador recoja una llave. Esto debería ocurrir cuando el jugador toca el volumen de colisión de la llave. 

Añadirás un evento que pertenece al componente de colisión Capsule. Un evento se activa cuando ocurre algo durante la jugabilidad. En este caso, cuando el actor jugador se solape con la cápsula de la llave, la llave debería realizar algunas acciones.

Para añadir un evento solapado y comprobar si el actor solapado es el jugador, sigue estos pasos:

1. Abre el blueprint BP_Key y ve a una zona vacía del grafo de eventos.

2. En el panel Componentes, haz clic derecho en el componente Capsule y selecciona Añadir evento > Añadir OnComponentBeginOverlap. El nodo asociado aparecerá en tu grafo de eventos. Este nodo de evento se activa si se produce un solapamiento entre este y otro actor.

   

   El nodo de evento contiene información sobre ese evento. Por ejemplo, el actor solapado que activa el evento se pasa a través del pin Otro actor.

3. Arrastra la variable OtherActor de la lista Variables al grafo y selecciona Establecer. Un nodo Set (configurar) guarda un nuevo valor para esa variable.

4. Arrastra el pin Exec del nodo de evento OnComponentBeginOverlap y conéctalo a la entrada Exec del nodo Set Other Actor. 

5. Arrastra el pin Other Actor del nodo de evento OnComponentBeginOverlap y conéctalo a la entrada Other Actor del nodo Set Other Actor.

   

6. Antes de hacer nada con la llave, comprueba si el actor solapado es el jugador, ya que ese es el único personaje que debería poder recoger llaves. Sabrás que es el jugador si tiene la interfaz de Blueprint.

   Haz clic derecho cerca del nodo Sety añade un nodo Does Object Implement Interface.

7. En el nodo Does Object Implement Interface, cambia el pin Interface a BPI_PlayerKeys.

8. Conecta el pin de entrada Test Object al pin azul del nodo Set Other Actor. Este pin funciona como un nodo Get Other Actor.

9. En el nodo Does Object Implement Interface, arrastra el pin Return Value y añade un nodo Branch. 

10. Conecta el pin de entrada Ejecución del nodo Branch al nodo Set. 

    

Un nodo Branch comprueba si una condición es verdadera o falsa para que puedas ejecutar distintas acciones en función del resultado. En esta sección, crearás lógica para dos escenarios, true y false, en función de lo que ocurra si el actor solapado es o no el jugador. 

Para llamar a la función de añadir llave cuando el jugador haya tocado la llave, sigue estos pasos:

1. Si el resultado de Branch es true, el actor puede recoger llaves, así que activa la función de evento de la interfaz. Arrastra desde el pin True del nodo Branch y añade un nodo BPIAdd Key (Message).

   Estás añadiendo un nodo de mensaje en lugar de un nodo de función normal porque cuando llamas a una función de interfaz de Blueprint, estás enviando un mensaje. El blueprint objetivo solo responde si implementa esa interfaz.

2. Arrastra el pin Target del nodo Fn BPIAdd Key y añade un nodo Get Other Actor.

3. Arrastra el pin Key Type y añade un nodo Get Key Type. Esta es otra forma de añadir referencias de variable. 

   

4. Cuando se recoja la llave, esta debería desaparecer con un breve retraso para que no se pueda volver a recoger. Para conseguir esto, arrastra el pin de ejecución del nodo Fn BPIAdd Key y añade un nodo Delay. Mantén la duración de 0.2 que viene por defecto. 

5. Cuando el temporizador termine, la llave debería desaparecer, así que conecta un nodo Destroy Actor al pin Completed del nodo Delay. Asegúrate de que Target esté establecido en self, lo que significa que el actor llave debería eliminarse del nivel.

   

6. Guarda y compila tu blueprint.

  El grafo de eventos completo de la llave debería tener este aspecto: 

Aquí tienes de nuevo el diagrama de recursos del principio de esta página, pero esta vez muestra un resumen del conjunto de recursos y funciones que has creado y cómo se combinan para crear el aspecto y el comportamiento de la llave: 

Probar la llave

Vuelve a tu nivel y añade una llave de cada color. Ahora puedes intentar recoger las llaves en el juego pasando sobre ellas.

Siguiente

En la siguiente sección, cambiarás el blueprint de la puerta para que pueda cambiar de color como las llaves y permanecer cerrada a menos que el jugador haya cogido la llave correspondiente.

• 

  Abrir puertas con llaves

  Configura el blueprint BP_DoorFrame para que las puertas puedan cambiar de color y solo se abran con la BP_Key correspondiente.