Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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
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.
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.
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
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
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.
1
2
3
4
5
6
7
8
9
10
//AUE4DemoGameMode.cpp
#include "UE4Demo.h"
#include "UE4DemoGameMode.h"
#include "UE4DemoPlayerController.h"
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
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.
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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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();
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
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.
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
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
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
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"
//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();
/**
* 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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
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.