Sunteți pe pagina 1din 30

Introduccin al desarrollo de video juegos con

Unreal Engine 4
26 respuestas

Unreal Engine 4, en mi opinin, es uno de los motores de juegos ms potente que existe en la
actualidad, y el equipo de Epic Games lo ha puesto por completo a disposicin de todos bajo una
licencia 19 USD mensuales.
Este primer tutorial pretende dar una introduccin al UE4. Crearemos la base de nuestro juego,
donde tendrs al personaje protagnico caminando por el nivel usando una cmara fija, con
controles bsicos. Este simple inicio nos permitir aprender a importar los modelos 3D al proyecto.
Crear la clase necesaria para controlar al personaje. Entender la filosofa que sigue el framework de
Unreal en su modelo de clases. Una introduccin a la programacin en Unreal Engine usando C++.
La comunicacin entre C++ y el Editor. Los mecanismos de animacin del personaje y una
introduccin al Visual Scripting usando el Blueprint Editor.
Obteniendo el Unreal Engine 4
El proceso para obtener el motor es sper simple. Entra en https://www.unrealengine.com/register
regstrate y paga los primeros 19 USD, creme, probablemente estos sean los 19 USD que ms
alegra te darn en la vida :). Ahora tendrs acceso a lo mismo con lo que trabaja el equipo de Epic
Games.
El prximo paso es obtener el motor. Este lo podemos tener de dos formas, directo el ejecutable
desde el Launcher que al abrirlo nos dar para bajar la ltima versin o compilando todo el cdigo
fuente sip, as mismo, por si fuera poco, tenemos acceso ha todo el cdigo fuente del motor.
En el sitio se describen bien los pasos para bajar los fuentes desde
https://github.com/EpicGames/UnrealEngine/releases y los pasos para compilarlo as que nos
detendremos aqu. De todas formas si tienes algn problema con el proceso puedes dejarme tus
comentarios.
Requisitos antes de comenzar
Es vlido aclarar en este momento que este y los prximos tutoriales asumen que tienes un dominio
AVANZADO de C++ y del desarrollo de juegos.
Modelo 3D del personaje protagnico y sus animaciones
Lo primero que necesitamos para comenzar nuestro juego es el modelo 3D del personaje principal
con sus animaciones. Todos los modelo 3D que conforman un juego, tanto los personajes como los
objetos y las animaciones son creados por los diseadores y animadores de nuestro equipo, con

herramientas de modelado y animacin 3D como Maya, 3DsMax o Blender. Al terminar el proceso


de modelacin y animacin en estas herramientas, se exporta el modelo, el esqueleto y las
animaciones en formato FBX.

Como en lo personal, el modelado y la animacin 3D se me da muy mal


vamos a partir
de los recursos en FBX de uno de los proyectos de ejemplo que viene con el UE4. Esto es
exactamente lo que nos dara nuestro equipo de diseo. Puedes bajar los recursos aqu:
https://d26ilriwvtzlb.cloudfront.net/a/a7/ThirdPerson_FBX.zip
Descomprime el .zip, de momento solo trabajaremos con HeroTPP.FBX, Walk.FBX y Idle.FBX. Si
tienes algn software de modelado 3D, como Maya por ejemplo, puedes importar estos ficheros
para que les des un vistazo de cerca.

Archivo Hero.FBX cargado en Maya 2015. Vista del esqueleto.

Archivo Hero.FBX cargado en Maya 2015. Vista del modelo.

Hero.FBX es el modelo 3D de nuestro personaje con su esqueleto para poderlo animar. Idle.FBX y
Walk.FBX son las animaciones de reposo y caminar del personaje. En estos dos ltimos archivos no
se encuentra el modelo ya que no es necesario, para las animaciones solamente necesitamos la
informacin del movimiento de los huesos del esqueleto, por lo que al exportar las animaciones no
hay que incluir el modelo.
Creando un nuevo proyecto en Unreal Engine 4
Ya con nuestro modelo 3D y sus animaciones en formato FBX estamos listo para comenzar. Lo
primero es crear el proyecto. Crear un nuevo proyecto en Unreal Engine es sper simple. Abrimos el
editor y nos muestra una ventana con dos pestaas: Project, que contiene los proyectos existentes
previamente creados y New Project, que como es lgico, nos permite crear un nuevo proyecto.
Una de las primeras cosas geniales que encontramos al intentar crear un proyecto nuevo, es que ya
el UE4 viene con un grupo de Proyectos Plantilla que podemos usar como base de nuestro juego,
segn el estilo que queramos crear. 3ra Persona, 1ra Persona, Top-Down o Side-Scroller.

Como el objetivo que tiene este primer tutorial, es una introduccin al UE4, no vamos a usar
ninguna de estas plantillas relativamente avanzadas, vamos a crear nuestro proyecto prcticamente
desde cero, usaremos el Template Basic. Selecciona New Project/Basic Code y abajo en el campo
nombre escribimos el nombre de nuestro proyecto, en este caso yo usar UE4Demo. Por ltimo da
clic en Create Project.

Ventana para Crear o Abrir un proyecto en Unreal Engine 4

Hecho esto se crea automticamente el proyecto y se abre en el IDE correspondiente segn el


sistema que usemos. Para Windows es Visual Studio 2013 y para MAC OS es XCode 5.1. Este
tutorial es desarrollado en MAC OS, por lo que estoy usando como IDE de programacin el XCode.
Una vez abierto el XCode con el proyecto, tenemos que compilarlo para poderlo abrir en el Editor.
Da clic en la esquina superior izquierda para seleccionar el Scheme UE4DemoEditor Mac y
despus Men Product/Build For/Running.
El proceso de compilacin demorar unos segundos. Una vez que termina podemos seleccionar
desde el men del XCode, Product/Run. Esto nos abrir automticamente el Editor con nuestro
proyecto.

Unreal Engine 4 Editor con nuestro nuevo proyecto acabado de abrir

UE4 nos crea una escena con algunos objetos agregados a la misma. De momento vamos a
dejarlo. Puedes dar clic en el botn Play de la barra Superior (Toolbar) para ver lo que tenemos. Por
defecto tendremos el control de la cmara con el mouse y el teclado y podremos desplazarnos por
la escena, pero por supuesto, este no es el objetivo, nosotros queremos que entre en este mundo

nuestro personaje
Importando modelo 3D de nuestro personaje
Ya nuestro equipo de diseo nos entreg el modelo exportado en FBX con su esqueleto y su dos
animaciones bsicas :), ahora vamos a importarlo en el proyecto. En el Panel de la esquina inferior
izquierda del Editor tendemos el Content Browser. En este panel es donde tendremos organizados
todos los recursos de nuestro juego. Da clic en el Botn New y selecciona New Folder y dale un
nombre a la carpeta, por ejemplo Character. Hecho esto tendremos una nueva carpeta en el

Content Browser, entra en ella, selecciona Import y busca el FBX del personaje: Hero.FBX (los FBX
de las animaciones los vamos a importar ms tarde). Recuerda que en este FBX lo que tenemos es
el modelo 3D del personaje con su esqueleto. Al dar en OK nos sale la ventana FBX Import de UE4
y ya automticamente seleccionado Skeletal Mesh.

Ventana FBX Import del Unreal Engine 4

Vamos a tomarnos unos minutos para un poco de teora. Como puedes ver en esta ventana de
import se muestran tres tipos de recursos que se pueden importar desde FBX. Static Mesh, Skeletal
Mesh y Animation.
Static Mesh: Un Static Mesh es un objeto esttico de nuestro juego, por ejemplo una silla, un
edificio. O sea, solamente el modelo 3D sin animacin, sin esqueleto.
Skeletal Mesh: Un Skeletal Mesh, es exactamente lo que estamos importando ahora, un modelo 3D
con un esqueleto asociado para ser animado. O sea, todos los personajes de nuestro juego seran
Skeletal Mesh.
Animation: Un Animation, es la informacin de transformaciones de los huesos de un esqueleto
para darle vida a las acciones como caminar, saltar, etc. Lo que tenemos en Idle.FBX y Walk.FBX
que importaremos ms adelante.
Automticamente UE4 detecta que lo que estamos importando es un Skeletal Mesh no es necesario
cambiar ms nada, los parmetros por defecto son suficiente, da clic en el botn Import. En caso de

algn warning en el proceso de importacin, ignralo. En prximos tutoriales veremos todo el


proceso de Exportar/Importar y el Animation Rigging Toolset que nos da Epic para preparar los
modelos y las animaciones y abordaremos en detalles este tema.
Una vez importado el modelo en el Content Browser tendremos 3 nuevos elementos: Hero
(SkeletalMesh), Hero_PhysicsAsset (PhysicsAsset) y Hero_Skeleton (Skeleton).
Si haces doble clic en el SkeletalMesh puedes abrir el modelo importado en el Editor Persona de
UE4. Persona es el editor de Skeleton, Skeletal Meshes, Animations Blueprints y otros elementos de
animacin en UE4.

El Skeletal Mesh de nuestro hroe en el Persona Editor

Al abrir el SkeletalMesh en Persona a la izquierda tendremos el Skeleton Tree que es el rbol con
todos los huesos que conforman el esqueleto del modelo. En el panel de abajo tenemos el Mesh
Details. Este panel est compuesto por varias secciones, con los Materiales aplicados al modelo

(De momento no tenemos ningn material, o mejor dicho, solamente tenemos un material por
default que le da esa vista gris opaca a nuestro personaje)
El Hero_PhysicsAsset es el PhysicsAsset que se genera automticamente al importar el Skeletal
Mesh, este asset de momento no lo usaremos, en prximos tutoriales veremos para que es, pero si
eres muy curioso dale doble clic, te abrir el editor que trae UE4 para manipular este tipo de assets.
En la esquina superior izquierda tiene un botn que dice Simulate, da clic en l y mira lo que pasa.
Eso te dar una nocin del objetivo de este recurso generado automticamente al importar el
Skeletal Mesh.
Por ltimo el Hero_Skeleton es solamente el esqueleto del modelo que importamos, pero el
esqueleto por separado. Una caracterstica genial de UE4 es que podemos compartir el mismo
esqueleto entre distintos modelos 3D que sean relativamente parecidos en su modelo. En vez de
tener que importar siempre para cada uno de estos el modelo 3D y el esqueleto, solamente
importamos el esqueleto una vez, y podemos asociar distintos modelos a este esqueleto.
Bien, ya tenemos en nuestro proyecto los recursos del personaje principal, vamos ahora a lo que

nos gusta, el cdigo


Introduccin a la programacin en Unreal Engine 4
Un proyecto en Unreal Engine 4 est compuesto bsicamente de dos grandes piezas que trabajan
en conjunto. Los niveles, que es lo que se trabaja en el Editor y el proyecto de programacin, que
trabajamos en el IDE de programacin. Vimos como al crear un nuevo proyecto en UE4 se crean
ambas partes. Ahora vamos a trabajar en la segunda parte, la parte del cdigo.
En Unreal Engine 4 se programa en C++, al crear un nuevo proyecto, automticamente se crea un
proyecto en el XCode (o Visual Studio si usas Windows) con las clases bsicas para nuestro juego.
Abre tu IDE de programacin con el proyecto creado. Dentro de la carpeta Source es que se
encuentran los fuentes nuestros. Dentro de la carpeta Engine estn todos el framework. Tener
acceso a esto es genial, porque sirve de mucha ayuda para revisar como estn implementadas las
clases, o para que es una determinada propiedad, viendo los comentarios puestos por el propio
equipo de Epic. Antes de crear nuestra primera clase vamos a comentar rpidamente la filosofa
que sigue Unreal Engine en su framework.
En UE4 todos los elementos que aparecen en nuestro juego son Actors (heredan de la clase
AActor). Una silla, una mesa, un enemigo o el personaje principal. Los elementos del juego que son
controlados, o sea que no son estticos, que tienen un comportamiento, son Pawns. Hay un tipo
especial de Pawn que es el Character. El Character es el Pawn que representa al personaje
principal y tiene implementaciones particulares que solo tendr el Pawn que ser controlado por el

jugador. Por ejemplo, si en nuestro juego tenemos al personaje principal y a un enemigo. El


personaje principal ser un Character y el enemigo ser un Pawn solamente. Ahora todos los
Pawns son controlados por una clase Controller, para el caso del Character, este es controlado por
un PlayerController. El PlayerController es la clase que recibe las entradas del jugador, del ser
humano, y mediante ellas controla al personaje en el juego, al Character. Bsicamente el
PlayerController representa al ser humano, el Character (Tipo especial de Pawn) representa al
personaje dentro del juego y es controlado por el PlayerController. Mientras que los otros Pawns
pueden ser controlados, por ejemplo, por AIController.
. . . sip :S, bastante enredado, pero poco a poco a medida que te familiarices con Unreal Engine
dominars esta filosofa, la jerarqua de clases y la relacin entre ellas.
Volviendo al cdigo, dentro de la carpeta Source tenemos una carpeta con el nombre que le dimos
al proyecto, en mi caso UE4Demo y dentro unas pocas clases con las que comenzar nuestro juego.
La primera clase a tener en cuenta es UE4DemoGameMode esta es la clase que define el
GameMode de nuestro juego. En Unreal la clase GameMode define las reglas del juego, por
ejemplo, las condiciones en las que se gana, las condiciones en las que se pierde etc, adems es la
encargada de definir el PlayerController, el Pawn por defecto, entre otras muchas cosas. Es el
ncleo del juego. Si abrimos el .h veremos que es una clase que hereda de AGameMode y de
momento no tiene ms nada.

1
2
3
4
5
6
7
8
9
10
11

//AUE4DemoGameMode.h
#pragma once
#include "GameFramework/GameMode.h"
#include "UE4DemoGameMode.generated.h"
UCLASS()
class AUE4DemoGameMode : public AGameMode
{
GENERATED_UCLASS_BODY()
};

Como notars de seguro, la clase tiene en su declaracin dos macros que te llamarn la atencin,
UCLASS() y GENERATED_UCLASS_BODY
Unreal Engine posee un robusto sistema para el manejo de objetos. La clase base para los objetos
en Unreal es UObject. el macro CLASS puede ser usado en clases que derivan de UObject, de esta
forma el sistema manejador de UObjects es avisado de la existencia de esta clase.
Al incluir estos macros logramos que la clase a bajo nivel sea tratada por los mecanismos de Unreal
como el Recolector de basura, Serializacin, Inicializacin automtica de las propiedades,
Integracin automtica con el Editor etc.

Ahora vamos a ver la implementacin de nuestro GameMode. Como vers en el


UE4DemoGameMode.cpp tendrs solamente la implementacin del constructor.

1
2
3
4
5
6
7
8
9
10

//AUE4DemoGameMode.cpp
#include "UE4Demo.h"
#include "UE4DemoGameMode.h"
#include "UE4DemoPlayerController.h"

AUE4DemoGameMode::AUE4DemoGameMode(const class FPostConstructInitializeProperties& PCI


: Super(PCIP)
{
PlayerControllerClass = AUE4DemoPlayerController::StaticClass();
}

El constructor del GameMode de nuestro juego de momento solamente tiene la inicializacin del
atributo PlayerControllerClass. PlayerControllerClass es el PlayerController para nuestro juego, o
sea, la clase que ser la interfaz entre el ser humano y el Character que este controlar. Aqu
simplemente es inicializada con una instancia esttica de nuestro UE4DemoPlayerController. Por
eso es que podemos movernos como un fantasma por todo el nivel cuando corremos el proyecto
ahora mismo. Tenemos un PlayerController, pero como no tenemos un Character no tenemos
cuerpo dentro del juego.
La otra clase que tenemos ya previamente creada es UE4DemoPlayerController. Esta es la
implementacin del PlayerController de nuestro juego y como vers est vaca, de momento no
necesitamos nada personalizado en ella, todo lo necesario para nuestro PlayerController de
momento est en la clase base APlayerController, pero dejamos esta clase por aqu para cuando
necesitemos implementar algn comportamiento personalizado.
Bien, basta de teora, vamos a la practica.
Ya tenemos importado en el Editor los recursos que conforman a nuestro personaje, pues vamos a

acabar de hacerlo entrar en escena


Creando nuestra primera clase en Unreal Engine
Como lo primero que vamos a hacer es darle vida a nuestro personaje, la clase que vamos a crear
es la clase del personaje. Como comentamos anteriormente, el personaje controlado por el jugador
es un Pawn, pero es un Pawn especial, es un Character. Por lo que la clase que controle al
personaje protagnico de nuestro juego tiene que heredar de Character.

Para agregar una nueva clase al proyecto la forma ms cmoda de hacerlo es desde el Editor.
Vuelve al Editor y mediante el men principal selecciona File/Add Code to Project. Tendremos una
ventana para seleccionar la clase base de la nueva clase que como dijimos ser Character. En esa
ventana puedes ver las otras clases bases comunes en Unreal Engine y una pequea descripcin
de las mismas. Selecciona Character, da en el botn Next, escribe el nombre para tu clase, por
ejemplo, HeroCharacter y finaliza el proceso. Al finalizar el Editor te pregunta si quieres abrir la
clase en el IDE, le damos OK y ya veremos ah nuestra clase HeroCharacter creada. La estructura
de momento ya es conocida, una clase C++ normal que hereda de ACharacter y con los macros ya
explicados UCLASS() y GENERATED_UCLASS_BODY().
Configurando el Character desde el Blueprint Editor.
Ya tenemos nuestra clase para representar el personaje protagnico de nuestro juego, este es un
buen punto para comentar una de las cosas que en lo personal ms trabajo me cost adaptarme al
entrar en el mundo de Unreal Engine, sobre todo porque llegu a Unreal Engine despus de trabajar
mucho en el desarrollo de juegos 2D con motores como el Cocos2D. En este caso todo se hace
desde cdigo (aunque ya a estas alturas han varios Editores geniales para Cocos2D). En UE4 la
filosofa de trabajo es muy distinta, aqu por supuesto que podemos hacerlo todo desde
programacin pero esto implica que el ritmo de produccin generalmente ser ms lento y propenso
a bug. Por este motivo al desarrollar juegos sobre Unreal Engine trabajaremos indistintamente con
el Editor o directamente desde el cdigo. Bsicamente es decisin de los desarrolladores cuando
usar uno u otro.
Para demostrar el engranaje entre el cdigo en C++ y el Editor en Unreal Engine vamos a configurar
nuestro Character en los dos lados, esto tambin nos permitir demostrar lo genial que quedan
comunicados el cdigo C++ y el Editor.
Bien, ya tenemos desde cdigo nuestra clase para representar al Character, vamos ahora a
configurar los componentes del Character pero desde el Editor. Abre el Editor y en el Toolbar
tenemos el botn Blueprints. Selecciona Blueprints/New Class Blueprint en la parte de abajo de la
ventana hay una seccin que dice Custom Classes, selecciona ah y busca la clase que acabamos
de crear para nuestro Character, HeroCharacter, y le ponemos un nombre, por ejemplo,
HeroCharacterBlueprint y selecciona para que se cree dentro de la carpeta Game/Character. Una
vez terminado el proceso se abrir el Blueprint Editor en el modo Components. Desde aqu
podemos configurar todo nuestro Character.

A la izquierda del editor tenemos el panel Components este panel contiene todos los componentes
que conforman el Character al seleccionar uno, en el panel de abajo se muestran las propiedades
de ese componente. El CharacterMovements como el nombre lo indica es el componente que
contiene las propiedades que afectan el movimiento del Character, por ejemplo, aqu tenemos Max
Walk Speed que es el mximo de velocidad que toma el personaje al desplazarse, hay muchsimas
ms propiedades, dale un vistazo a todas por arriba para que tengas una idea de todo lo que se
puede configurar en el Character con respecto al movimiento.
El otro componente que tiene un Character es el CapsuleComponent. El CapsuleComponent es
usado para la deteccin de colisiones con el personaje. Es esa capsula transparente que se ve en el
Viewport del Editor y es la zona de colisin del personaje.
Por ltimo dentro del CapsuleComponent tenemos un Mesh, que como ya te imaginars es el Mesh
que representa a nuestro personaje. Adems hay un ArrowComponent que nos ayuda para saber la
direccin del Character.
Bien, el primer paso ser acabar de configurar el Mesh de nuestro Character. Selecciona en el panel
de Componentes el componente Mesh y en el panel detalles en la seccin Mesh tienes la propiedad
Skeletal Mesh despliega el combobox que hay aqu y selecciona el nico Skeletal Mesh que
tenemos en nuestro proyecto que creamos al importar el fbx de nuestro hroe. Al hacer esto en el
Viewport se ver el modelo de nuestro hroe. Usa las herramientas de traslacin y rotacin para
colocar el Mesh dentro del CapsuleComponent y mirando en la misma direccin que el Arrow
Component. Por ltimo da clic en el botn Save en la esquina superior derecha del Editor.

Mesh del personaje en la posicin correcta en el HeroCharacterBlueprint

Hecho esto acabamos de darle un cuerpo a nuestro Character. Vamos a probar. Cierra el Editor del
Character y corre el juego a ver que tenemos.

como notars no hay ningn cambio, seguimos teniendo control gracias al


PlayerController por defecto pero no tenemos nuestro personaje ni nada. Bien, el problema es que
nos faltaron algunas cosillas.
Primero, asegrate que tienes configurado bien el GameMode. Da clic en el botn World Settings
del Toolbar y asegrate tener seleccionado en la seccin GameMode nuestra clase
U4DemoGameMode, debajo de GameMode tendrs los elementos configurados en este
GameMode en PlayerControllerClass est nuestro PlayerController (UE4DemoPlayerController) ya
que en el constructor de la clase UE4DemoGameMode inicializa esa propiedad, pero como notars
Default Pawn Class dice Default Pawn. Ese es exactamente el problema que tenemos. Creamos
nuestro Character y le dimos un cuerpo pero no hemos definido en el GameMode que
HeroCharacter es el Character (el Default Pawn Class ) de nuestro juego.
Vamos ha hacer esto desde el cdigo para demostrar nuevamente la comunicacin entre los
componentes del Editor y el cdigo en C++. Cierra el Editor abre el proyecto C++ y busca la clase

UE4DemoGameMode modifica la implementacin del constructor para que quede de la siguiente


forma.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

AUE4DemoGameMode::AUE4DemoGameMode(const class FPostConstructInitializeProperties& PCIP


: Super(PCIP)
{
PlayerControllerClass = AUE4DemoPlayerController::StaticClass();

//Obtiene en PlayerPawnBPClass.Object la referencia al HeroCharacterBlueprint crea


static ConstructorHelpers::FObjectFinder<UClass>
PlayerPawnBPClass(TEXT("Class'/Game/Character/HeroCharacterBlueprint.HeroCharacterBlue

//Inicializa el atributo DefaultPawnClass con el HeroCharacterBlueprint creado y c


if (PlayerPawnBPClass.Object != NULL)
{
DefaultPawnClass = PlayerPawnBPClass.Object;
}
}

Vamos a dar un stop aqu para explicar que acabamos de hacer con estas pocas lneas porque
aunque tengas experiencia en C++ de seguro que esta sintaxis te parecer algo rara. En la primera
lnea lo que hacemos es buscar y obtener la instancia de la clase HeroCharacter creada en el editor
mediante el Blueprint Editor. Creamos una variable del tipo FObjectFinder, FObjectFinder es una
estructura parametrizada publica que se encuentra dentro de otra estructura de nombre
ConstructorHelpers. FObjectFinder recibe en su constructor la direccin del objeto que vamos a
instanciar, si el objeto es encontrado satisfactoriamente su instancia se almacena en la propiedad
Object.
Un buen consejo, como tenemos los fuentes del Framework, puedes ver la implementacin de todas
estas estructuras ConstructorHelpers, FObjectFinder. En XCode basta con dar clic sobre su nombre
con la tecla cmd presionada. Esto te llevar a la declaracin de la estructura. Tomate unos minutos y
dale un vistazo por arriba para que entiendas mejor su funcionamiento. Por ltimo notar que para
definirle la ruta a FObjectFinder usamos el Macro TEXT, bsicamente todos los strings que
escribamos directo en el cdigo lo tendemos que hacer con esto, para que el compilador pueda
convertir el string al tipo de dato correcto, en este caso un TCHAR *.
Bien, pues en teora tenemos en PlayerPawnBPClass.Object la instancia de nuestro Character
(PlayerPawnBPClass es el nombre que le dimos a la variable que acabamos de crear de tipo
FObjectFinder), lo que queda es inicializar la propiedad DefaultPawnClass con este objeto. La clase
GameMode tiene la propiedad DefaultPawnClass que define el Pawn que usar el personaje.
Listo, compila y ejecuta el juego. Al arrancar el juego automticamente se agrega al Level nuestro
personaje. Esto es porque en el Level que nos crea el Unreal Editor por defecto con la plantilla que
seleccionamos al crear el proyecto, tiene un Actor de tipo Player Start. Y el GameMode

automticamente busca en el Level si hay una instancia de un Player Start y agrega en esa posicin
el Character.
Pero que problema tenemos ahora, perdimos el control, ya no podemos desplazarnos por la escena
y la cmara est como en los ojos del personaje :(. Bien, vamos a solucionar este asunto
configurando temporalmente una cmara esttica en nuestro juego.
Configurando una cmara esttica desde C++
En el Editor da clic derecho dentro del ViewPort y selecciona del men desplegable Place
Actor/Camera. Usa las herramientas de traslacin y transformacin para apuntar la cmara en la
direccin del Play Start, para que se vea el personaje. As me qued a mi:

Ahora vamos a decirle al Unreal que la vista del juego ser desde esta cmara. Para esto tenemos
que comentar algo de teora.
Como hablamos anteriormente segn la filosofa de Unreal es el PlayerController la interfaz entre el
personaje protagnico del juego (el Character) y el ser humano. Por lo que es lgico que lo referente
a la vista del juego sea implementado aqu. PlayerController tiene el mtodo
SetViewTargetWithBlend este mtodo permite definir en cualquier momento a donde es que est
mirando la cmara del juego. Lo que vamos a hacer es llamar a este mtodo y decirle que use la
cmara que pusimos en el Level como la cmara del juego.

Podemos cambiar la direccin a la que apunta la cmara de nuestro juego en cualquier momento,
pero en este caso queremos que desde el inicio sea la direccin a la que apunta la cmara que
agregamos al level. Para esto vamos a usar un evento muy usado en Unreal que es el evento
BeginPlay. todas las clases que hereden de AActor tienen este mtodo que se llama, como dice su
nombre, cuando inicia el juego. Vamos a sobrescribir este mtodo en nuestro PlayerController (que
deriva de AActor) para en ese momento cambiar la cmara del juego.
Abre UE4DemoPlayerController.h y abajo del macro GENERATED_UCLASS_BODY() agrega la
siguiente lnea: virtual void BeginPlay() override; con esto hacemos visible el mtodo BeginPlay en
nuestra clase UE4DemoPlayerController para poderlo sobrescribir en el .cpp.
Abre ahora UE4DemoPlayerController.cpp y agrega el siguiente mtodo debajo del contructor.
Revisa con detenimiento los comentarios para que entiendas lo que se hace dentro del mtodo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/** Metodo heredado de la clase AActor se llama automaticamente por el motor cuando c
void AUE4DemoPlayerController::BeginPlay()
{
//Llamamos el Begin Play de la clase padre
Super::BeginPlay();

//Recorremos todos los Actores en el Level mediante el TActorIterator


//TActorIterator es un iterator parametrizado que nos permite recorrer todos los
for (TActorIterator<ACameraActor> It(GetWorld()); It; ++It)
{
//Obtenemos el actor actualmente en el loop. Como solo tenemos un solo ACamer
vez

ACameraActor* _mainCamera = *It;

//Configuramos el nuevo punto de vista del juego con la camara.


//SetViewTargetWithBlend puede recibir ms parametros, pero tienen valores po
modificarlos.
this->SetViewTargetWithBlend(_mainCamera);
}
}

Listo !! compila y corre. Ahora vers el juego usando la cmara que agregamos al Level y ya podrs
ver nuestro Character agregado a la escena.
Configurando una cmara esttica mediante el Blueprint Editor
Bien, quisiera hacer un parntesis aqu para volver a tocar el tema del Blueprint Editor. Al comenzar
en Unreal Engine muchos chocamos con la incgnita: Cmo hago esto? Mediante C+ o mediante el
Blueprint. Al final la decisin es de cada cual y a medida que vayas cogiendo soltura en Unreal
Engine sabrs al directo si lo que vas a hacer en C++ o en el Blueprint Editor. Quiero aprovechar
este momento para demostrar esto. Vamos a hacer lo mismo que acabamos de implementar en C+

+, o sea, cambiar la cmara del juego, pero ahora sin escribir una lnea de cdigo, todo lo haremos
mediante el Blueprint Editor.
En el Editor da clic en el botn Blueprint del Toolbar y selecciona Open Level Blueprint esto te abrir
el Blueprint Editor con el archivo Blueprint para el Level completo. Digamos que es en este Blueprint
donde implementaremos las cosas generales del nivel.
Siguiendo la lgica que usamos para implementar esto desde C++. Lo primero que hicimos fue
implementar el Evento BeginPlay. Pues eso mismo haremos aqu, el Blueprint Editor es un Editor de
scripting visual, por lo que en este Editor lo que haremos bsicamente es programar pero con

grficos (si si . . . bien complejo de asimilar y entender la primera vez


) aqu podemos
agregar variables, eventos del sistema, funciones de clases especificas etc. En fin, todo, o casi todo
lo que haces en C++ lo podrs hacer en el Blueprint Editor.
Comenzaremos agregando el Evento Begin Play. Clic derecho en el centro de la pantalla desmarca
la opcin Context Sensitive y busca Event Begin Play. Acabamos de agregar a nuestro script visual
un Nodo que representa al mtodo Begin Play de nuestro juego. Ahora, segn nuestra
implementacin en C++ lo que hicimos dentro del BeginPlay fue obtener la referencia de la cmara
que tenemos en el Level y llamar al mtodo de la clase PlayerController SetViewTargetWithBlend
pasndole como parmetro la cmara. Pues eso mismo haremos aqu.
Primero, necesitamos una referencia al PlayerController, recuerda que este script es global a nivel
del Level y la implementacin de C++ la hicimos dentro del PlayerController.
Agrega un nuevo Nodo como ya sabes pero ahora ser Get Player Controller. Este nodo nos retorna
la referencia del Player Controller del juego. Ahora necesitamos llamar al mtodo
SetViewTargetWithBlend como mismo hicimos en C++. De nuevo agrega un nuevo Nodo de nombre
SetViewTargetWithBlend. Listo, ya tenemos todos los elementos que necesitamos para nuestro
algoritmo visual. Pero falta una cosa, conectarlos.
El Nodo Event Begin Play tiene como un puerto que representa la salida. O sea, lo que se va a
ejecutar cuando se lance este evento en el juego y si te fijas en el nodo Set View target with Blend
tiene un puerto de entrada y de salida. El de entrada es el que nos interesa. Da clic en el puerto del
evento Event Begin Play y arrastras la flecha hasta el puerto de entrada de Set View Target with
Blend, cuando te muestre una marquita verde sultalo. Con esto hemos hecho la conexin entre la
salida de Event Begin Play y Set View target with Blend. Que quiere decir esto, que cuando se
ejecute nuestro juego, se va a disparar el evento BeginPlay y se llamar al mtodo Set View target
with Blend. Pero que pasa, SetViewtargetWithBlend vimos que es un mtodo que pertenece al
PlayerController, por lo que hay que definirle al nodo Set View Target With Blend quien es el Player
Controller. El Nodo Get Player Controller tiene un puerto de salida que dice Return Value y el Nodo

Set View Target with Blend tiene un puerto de entrada que dice Target. Conecta estos dos puertos y
de esta forma estars diciendo que el mtodo SetViewTargetWithBlend que se llamar es el del
PlayerController retornado por el Nodo Get Player Controller. Por ltimo recuerda que hay que
pasarle como parmetro al SetViewTargetWithBlend el Actor que usar para configurar el nuevo
punto de mira. Para esto nos falta agregar un ltimo Nodo, el nodo que representa a la cmara.
Salva estos cambios, cierra el Editor y selecciona en el Level la cmara que agregamos
anteriormente. Ahora abre de nuevo el Editor da clic derecho y vers que tienes un acceso directo
para agregar un Nodo Camera Actor. Una vez agregado conecta el puerto de salida del camera
actor al puerto New View Target del Set View Target with Blend. Listo, ya tenemos nuestro script
visual completo. En la esquina superior izquierda tienes un botn que dice Compile. Da clic ah. Por
ltimo vamos a eliminar la sobre-escritura del mtodo Begin Play en la clase C++ ya no es
necesario (si quieres comntalo para que no pierdas el cdigo).
Cierra el Editor, abre el proyecto C++ y comenta en el UE4DemoPlayerController.h la declaracin
del mtodo BeginPlay. Ve ahora al UE4DemoPlayerController.cpp y comenta o elimina
completamente la implementacin del mtodo BeginPlay.
Listo !!. Compila y ejecuta el juego. Como notars, es idntico el resultado :). Ya te digo, es decisin
tuya implementar lo que quieras en el Blueprint Editor o en C++ tu mismo le iras encontrando las
ventajas y desventajas a cada mtodo segn lo que quieras hacer.

Tomate unos minutos si quieres, que an nos quedan varias cosas


Configurando las animaciones del personaje
De momento lo que tenemos es bastante poco funcional. Simplemente al abrir el juego vemos al
personaje protagnico, ya visto desde una cmara fija pero est ah quieto sin hacer nada y esttico
totalmente. Vamos a darle un poco de vida.

Recuerda que nuestro equipo de diseo


nos entreg adems del modelo con su
esqueleto en FBX las animaciones de caminar y reposo, tambin en formato FBX listas para
importarlas. Pues vamos a ello. Abre el Editor en el Content Browser crea una nueva carpeta, yo le
pondr Animations. Aqu tendremos todas las animaciones que importemos. Entra a la carpeta e
importa los dos FBX Walk.FBX e Idle.FBX. Al seleccionarlas vers que por defecto en la ventana de
FBX Import sale seleccionado Animations. Ms abajo tiene la opcin que permite ya en el momento
de la importacin seleccionar el esqueleto al que estn asociadas estas animaciones. Da clic ah y
selecciona Hero_Skeleton por ltimo da clic en Import.

Ya tenemos las animaciones de nuestro personaje, si quieres puedes darle doble clic desde el
Content Browser para abrirlas en el Persona Editor y ver un preview de las mismas. Desde este
Editor puedes ver todos los detalles de la animacin, reproducirla y muchas ms cosas que veremos
en prximos tutoriales.
Ya tenemos las animaciones ahora falta asociarlas con nuestro personaje.
Creando la maquina de estado y actualizando el Character con la animacin de reposo y
caminar mediante Animation Blueprints.
El Animation Blueprints es la herramienta que nos da Unreal Engine para implementar toda la lgica
de las animaciones del personaje de una forma sper simple. A partir de mquinas de estado y
visual scripting.
Vamos a crear entonces el Animation Blueprints para el personaje. Entra en el Content Browser a la
carpeta Animations da clic derecho en un espacio vaco y selecciona Animation/Animation Blueprint.
Esto te abrir la ventana de creacin de Animation Blueprint. En la seccin Parent Class selecciona
AnimInstance y abajo en la seccin Target Skeleton escribe el nombre del esqueleto que usa
nuestro hroe, Hero_Skeleton por ltimo da clic en el botn OK.
Automticamente se agrega al Content Browser un AnimBlueprint con el nombre seleccionado para
que lo cambies. Ponle el nombre que prefieras, por ejemplo HeroAnimBlueprint. Ahora, antes de
hacer algo en el HeroAnimBlueprint vamos a definirle en nuestro Character que ser este el
Blueprint que usar para sus animaciones. Para esto ve en el Content Browser a donde tienes el
Blueprint del character. En mi caso Game/Character/HeroCharacterBlueprint y dale doble clic. En la
esquina superior derecha, selecciona el Modo Defaults y vers que hay una seccin de nombre
Animation para la propiedad Animation Mode selecciona Use Animation Blueprint y para la
propiedad Anim Blueprint Generated Class selecciona la clase que acabamos de crear
HeroAnimBlueprint_C. Listo, guarda y cierra el Editor.

Ve ahora al HeroAnimBlueprint, dale doble clic y se te abrir el Persona Editor. De inicio tienes un
nodo Final Animation Pose. A este Node conectaremos la salida de lo que vamos a crear ahora,
pero primero, de nuevo un poco de teora.
En Unreal Engine hay un mecanismo sper genial e intuitivo para definir las animaciones que tienen
los personajes segn su estado y las condiciones que definen cada estado. O sea, si el personaje
est en reposo se animar la animacin de reposo, si el personaje est caminando se ejecutar la
animacin de caminando. Se pueden hacer ligamentos entre animaciones, para que estos cambios
sean mas fluidos, adems definir las condiciones de cada estado. Por ejemplo, para que el
personaje est en reposo su atributo velocidad tiene que estar en cero, para que est caminando
su atributo velocidad ser distinto de cero, y as. Todo esto se puede hacer mediante una maquina
de estado y un script visual en el Animation Blueprint.
Vamos a crear la maquina de estado, de momento ser muy simple. Dentro del AnimBlueprint Editor
da clic derecho y selecciona StateMachine/Add State Machine esto agrega un Nodo de tipo
StateMachine a la escena. Cmbiale el nombre a algo lgico, como HeroStateMachine o como
prefieras. Ahora, dentro de ese State Machine vamos a definir los distintos estados que tendr el
personaje. Da doble clic en el nodo State Machine para entrar a editarlo. Dentro tienes un nodo de
nombre Entry, da clic derecho Add State y ponle al nuevo nodo Idle de nombre. Ahora conecta,
como mismo hicimos en el level blueprint, el puerto de salida del nodo Entry al puerto de entrada del
nodo Idle que acabamos de crear.
Seguidamente vamos a definir la lgica del estado Idle. Dale doble clic al nodo Idle, da clic derecho
y selecciona Animation/Play Idle. Esto agrega el Nodo que representa la animacin Idle que
importamos anteriormente al Editor. ahora conecta este nodo al nodo Final Animation Pose.
Listo vamos a repasar como quedan todas las conexiones en cada uno de los niveles. De adentro
hacia afuera tenemos nodo Play Idle conectado al nodo Final Animation Pose. En el nivel superior
(HeroStateMachine) nodo Entry conectado al nodo Idle y por ltimo en el nivel superior (AnimGraph)
el nodo HeroStateMachine conectado al nodo Final Animation Pose. Hecho esto da clic en Compile
en la esquina superior derecha del Editor. En el panel de la izquierda podremos ver un preview ya
del personaje con la animacin del Idle

Ejecuta el juego. Ya tenemos a nuestro personaje en su estado de reposo y animndose


perfectamente.

Personaje principal ya en el juego en estado de reposo animndose correctamente.

Configurando los controles del juego

Muy bien, hasta ahora hemos creado y configurado el Character, hemos configurado una cmara
fija temporal para el juego y hemos configurado la primera animacin del personaje, el prximo paso

de seguro que sabes cual es . . . hacer caminar al chico


Primero vamos a definir los controles del juego. Para esto desde el Unreal Engine Editor men
Edit/Project Settings, Seccin Engine/Input, Bloque Bindings. Da clic en el botn del + en Axis
Mapping y despliega la flechita. En el campo para escribir, escribe MoveForward. Da clic en la
flechita al lado del EditText y despliega el campo y selecciona W y en Scale deja 1.0. Da clic de
nuevo en el + al lado del EditText de MoveForward selecciona del nuevo combobox la S y en Scale
pon -1.0.
Ahora da clic en el + de Axis Mappings para crear otra seccin al nivel de MoveForward. En el
nuevo EditText escribe MoveRight. Agrega dos hijos a MoveRight: A con Scale igual a -1 y D con
Scale igual a 1.

Lo que acabamos de hacer es definir los controles que tendr nuestro juego. El nombre que le
ponemos, por ejemplo, MoveForward es para conocer esta entrada desde programacin y lo que
seleccionamos en el combobox es el control que disparar esta accin. El valor de Scale es un valor
numrico que llega al mtodo desde programacin, generalmente con -1 y 1 es suficiente para la
mayora de los casos. Otra cosa a notar es que gracias a este valor de Scale las acciones que son
en una direccin y en su contraria las registramos con el mismo identificador (MoveForward por

ejemplo) y simplemente le cambiamos el valor de Scale a 1 si es hacia delante y a -1 si es hacia


atrs.
Bien, hecho esto vamos a programar en el Character la lgica para lograr el desplazamiento por la
escena con estos controles, de momento ser muy simple el desplazamiento del personaje en la
escena, pero suficiente para entender como funciona todo. Bsicamente necesitamos dos cosas.
Sobrescribir el mtodo virtual void SetupPlayerInputComponent(class UInputComponent*
InputComponent) de APawn para registrar los mtodos que se van a llamar cada vez que se detecte
las entradas que definimos, o sea un MoveForward o un MoveRight, y por supuesto, implementar el
desplazamiento del Character en dependencia de la entrada.
Abre la clase HeroCharacter.h y modifcala para que quede de la siguiente forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

UCLASS()
class AHeroCharacter : public ACharacter
{
GENERATED_UCLASS_BODY()
protected:
/**
* Se llama cuando el motor detecta la entrada configurada para 'MoveForward'.
* En este caso cuando el usuario toca la tecla W o S del teclado
*/
void MoveForward(float Value);
/**
* Se llama cuando el motor detecta la entrada configurada para 'MoveRight'.
* En este caso cuando el usuario toca la tecla A o D del teclado
*/
void MoveRight(float Value);

/**
* Metodo de la clase APawn que permite configurar los 'binding' de los controles
* Es llamado automaticamente por el Engine
*/
virtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) OVERR
};

Nada raro aqu, simplemente definimos dos mtodos en donde vamos a implementar la lgica para
cuando se detecte cada entrada y agregamos aqu tambin la declaracin del mtodo
SetupPlayerInputComponent de APawn para poderlo sobrescribirlo
Ahora pasa al HeroCharacter.cpp y modifcalo para que quede de la siguiente forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include "UE4Demo.h"
#include "HeroCharacter.h"

AHeroCharacter::AHeroCharacter(const class FPostConstructInitializeProperties& PCIP)


: Super(PCIP)
{
}

void AHeroCharacter::SetupPlayerInputComponent(class UInputComponent* InputComponent)


{
//Le dice al motor que cuando detecte las entrada de tipo MoveForward que llame al
AHeroCharacter::MoveForward
InputComponent->BindAxis("MoveForward", this, &AHeroCharacter::MoveForward);

//Le dice al motor que cuando detecte las entrada de tipo MoveRight que llame al m
InputComponent->BindAxis("MoveRight", this, &AHeroCharacter::MoveRight);

/**
* Se llama cuando se detecta la entrada de tipo MoveForward (Cuando el usuario toca
* Determina la direccin en la que est el personaje y le aplica un movimiento (posi
*
* @param Value Value es igual a 1 cuando se detecta W y -1 cuando se detecta S
*/
void AHeroCharacter::MoveForward(float Value)
{
if ((Controller != NULL) && (Value != 0.0f))
{
//Obtiene la rotacion actual
const FRotator Rotation = Controller->GetControlRotation();

// Crea el vector de direccion a partir de hacia donde est rotado y aplica el


const FVector Direction = FRotationMatrix(Rotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);

/**
* Se llama cuando se detecta la entrada de tipo MoveForward (Cuando el usuario toca
* @param Value Value es igual a 1 cuando se detecta D y -1 cuando se detecta A
*/
void AHeroCharacter::MoveRight(float Value)
{
if ( (Controller != NULL) && (Value != 0.0f) )
{
//Determina la direccin del movimiento hacia los lados. Notar que solo nos in
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// Crea el vector de la direccin y aplica el movimiento
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

47
48
49
50
51
52
53
54
55
56

AddMovementInput(Direction, Value);
}

Ya aqu si tenemos algunas cosas que comentar, pero de seguro a estas alturas tienes una idea de
todo. Primero, en SetupPlayerInputComponent usamos el parmetro que recibe para configurar los
mtodos que se van a llamar cuando se detecte cada una de las entradas. O sea, con
InputComponent->BindAxis(MoveForward, this, &AHeroCharacter::MoveForward); estamos
diciendo que cuando el Engine detecte la entrada MoveForward, que como definimos ser cuando
el jugador presione las teclas W o S del teclado, se llamar el mtodo MoveForward. Y el mismo
principio para la otra entrada.
Ahora vamos a ver la implementacin del mtodo MoveForward. Este mtodo recibe un parmetro
float, que es el valor Scale que registramos en el Editor. O sea, cuando se toque la W se llamar
este mtodo con 1.0 como parmetro y cuando se toque la S se llamar este mtodo con -1.0 como
Value.
El mtodo lo que hace es determinar la rotacin que tiene el modelo y el vector en la direccin a la
que est orientado y mediante el mtodo AddMovementInput hacemos que el personaje se mueva
en esa direccin. Fjate que se calcula la direccin y como se pasa Value que ser 1 o -1 entonces
el personaje se mover hacia delante o hacia atrs segn Value. AddMovementInput es un mtodo
de APawn que permite aplicar un movimiento al Pawn para el caso del personaje que no sea un
cuerpo fsico, como el nuestro. Para el caso del MoveRight fjate que es prcticamente lo mismo,
pero al calcular la direccin lo hacemos en base al eje Y y no con el eje X.
Listo, esto es todo lo que necesitamos. Compila y ejecuta el juego, cuando abra presiona las teclas
W,S,A,D del teclado para controlar al personaje. Cuidado no te caigas por los bordes de la

plataforma
Umm pero an tenemos dos problemas con este movimiento. Primero, el personaje no rota en la
direccin del movimiento como sera lo lgico, y el otro problema es que a pesar que se est
moviendo sigue con su animacin de reposo. Vamos entonces a solucionar estos dos problemas.

Primero, para solucionar el problema de la rotacin es muy fcil. Abre el HeroCharacter.cpp y


modifica el constructor para que te quede de la siguiente forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

AHeroCharacter::AHeroCharacter(const class FPostConstructInitializeProperties& PCIP)


: Super(PCIP)
{
//Por defecto esta propiedad viene en true para el Character.
//Pero en nuestro modelo de desplazamiento, no queremos que el personaje rote en
Controller.
bUseControllerRotationYaw = false;
//Configuracin del componente CharacterMovement

//Al estar en true habilita para que el character se rote en la direccin del mov
movimiento.
CharacterMovement->bOrientRotationToMovement = true;
//Factor de rotacin para la propiedad anterior.
CharacterMovement->RotationRate = FRotator(0.0f, 540.0f, 0.0f);

//Bajamos un poco el valor por defecto de MaxWalkSpeed para que el personaje cami
CharacterMovement->MaxWalkSpeed = 400.0f;

Recuerdas que el Character tiene un CharacterMovement verdad ?. Pues aqu lo que hicimos fue
modificar algunos valores para cambiar el comportamiento por defecto del Character. Puedes
revisar en el Editor desde el HeroCharacterBlueprint que creamos, todas las propiedades que tiene
el CharacterMovement, juega un poco con ellas para que veas todo lo que se le puede definir al
movimiento del Character.
Agregando animacin de caminando al personaje.
Vamos a trabajar ahora en el ltimo problema que tenemos, hacer que el personaje cuando est en
reposo tenga su animacin de reposo (como ahora) pero cuando est caminando reproduzca la
animacin de caminando, con esto veremos uno de los mecanismos que nos da Unreal Engine para
ligar dos animaciones de forma suavizada, los Blend Space.
Blend Space es el Nodo del Animation Blueprint que nos permite hacer blending entre dos
animaciones en base a la entrada de valores. En Unreal tenemos dos tipos: el Blend Space que es
para varias entradas y el Blend Space 1D que es para una sola entrada. Para este simple ejemplo
usaremos el Blend Space 1D ya que necesitamos solamente una entrada para lo que queremos
lograr, la velocidad del desplazamiento.
Abre el Editor y dentro de la carpeta Animations en el Content Browser da clic derecho para agregar
un Animations/BlendSpace1D ponle de nombre IdleWalkBlendSpace1D y dale doble clic para abrir
el Editor de este elemento. Aqu la idea es la siguiente, decirle las dos animaciones que harn

blending segn el valor de una variable. En el panel de las propiedades de IdleWalkBlendSpace1D


en el X Axis Label escribe Speed (esto es solo para una referencia, puede ser cualquier otra palabra
que te represente el valor que se tiene en cuenta para cambiar entre una animacin y otra). En el
rango pon 0 y 100. Ahora fjate que ms abajo tienes un espacio como de una grfica, arrastra
hacia ah desde el panel Asset Browser la animacin Idle y colcala al inicio del eje X, has lo mismo
para la animacin Walk y colcala al final del eje. Listo, ahora mueve el cursor sobre el eje y fjate
en el panel Preview como a medida que el valor se va modificando, el modelo va cambiando de su
estado Idle a Walk. Guarda y cierra este editor.

Configuracin del IdleWalkBlendSpace1D

Ahora vamos a modificar el HeroAnimBlueprint para en el State Machine al nodo Idle cambiar su
comportamiento. Abre el HeroAnimBlueprint ve desde el AnimGraph hasta el nodo Idle (si quieres
puedes cambiarle el nombre ahora a Idle/Walk) ya que dentro de este nodo se manejarn estos dos
estados. Entra para editarlo. Elimina el nodo de Idle que estamos usando ahora y agrega el
IdleWalkBlendSpace1D que acabamos de crear. Como ves este Nodo a diferencia del anterior tiene
un puerto de entrada con el nombre Speed (que se lo definimos cuando lo creamos) por lo que para
que funcione alguien le tiene que suministrar este valor. En el panel MyBlueprint hay un icono con
un +V que dice Variable. Esto es para agregar una nueva variable al grfico. Da clic aqu y dale el
nombre de Speed a la variable, arrstrala para el espacio de trabajo y cuando te pregunte Set/Get
selecciona GET. Por ltimo conecta Speed a IdleWalkBlendSpace1D y este al Final Animation Pose.

Ya tenemos el Nodo Idle/Walk listo, pero te estars preguntando a la variable Speed, quien le da
su valor ? Esto lo tenemos que definir en el EventGraph. Vamos a implementar un algoritmo que
en cada loop de la animacin obtenga el Pawn (que sera nuestro personaje) despus que se llame
al mtodo GetVelocity que retorna el vector de desplazamiento que lleva el personaje en ese
momento. Este vector por supuesto se modifica gracias a la implementacin del MoveForward y
MoveRight que hicimos anteriormente en C++. Cuando tengamos la velocidad, obtenemos la
distancia de ese vector y vamos a usar ese valor para darle valor a la variable Speed. Todo esto lo
vamos a hacer en el HeroAnimBlueprint/EventGraph.
Ya vimos anteriormente como es el Visual Scripting en el Blueprint Editor as que no tendrs
problema y ser otro momento para repasar su funcionamiento. Vale la pena aclarar en este punto,
que como dijimos anteriormente, todo esto se puede hacer desde programacin directo. Pero por
ejemplo, la lgica del comportamiento de las animaciones es uno de los casos donde es mucho
mejor hacerlo en el Blueprint para que quede todo el mecanismo de animacin del personaje en un
solo lugar y poderlo repasar y pre visualizar fcilmente.
Abre el HeroAnimBlueprint/EventGraph, agrega y conecta los Nodos para que te quede igual que la
imagen siguiente. No voy a repetir paso a paso todo el proceso, porque con la explicacin que
hicimos anteriormente del Blueprint Editor debes poder hacerlo por tu cuenta y entender todo lo que
hace el algoritmo.

Algoritmo del HeroAnimBlueprint/EventGraph con la lgica para setear el valor de la variable Speed
usada dentro del State Machine del personaje para cambiar entre las animaciones de caminando y
reposo.

Listo, compila y guarda el Blueprint y dale Play al juego Sper verdad !! ya tenemos nuestro
personaje movindose por el terreno correctamente segn queramos y cuando est detenido se
anima con su animacin de reposo y cuando est caminando se anima con su animacin de Walk.

S-ar putea să vă placă și