APOSTILA VARIADA UNREAL4 Alexandre Claudio

Prévia do material em texto

Este trabalho está licenciado sob uma Licença Creative Commons Atribuição-
NãoComercialCompartilhaIgual 4.0 Internacional. Para ver uma cópia desta licença, visite 
http://creativecommons.org/licenses/by-nc-sa/4.0/. 
Capa: Alexandre Ferreira e Sean Albuquerque – Imagem de fundo extraída da Unreal Engine 4, sem 
qualquer efeito de pós-produção aplicada além dos filtros do motor gráfico. 
Brasil – novembro de 2016 
 
 
 
 
 
 
Unreal 4 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Nota dos Autores 
O conteúdo aqui abordado possui teor informativo educacional sem fins lucrativos. 
Deixamos expressamente claro que está apostila pode ser utilizada tanto em cursos 
ou salas de aulas como também por qualquer entusiasta individual que queira 
desbravar um conteúdo em português que envolva a Unreal 4, e a programação 
visual Blueprints, de forma a sair um pouco do “Abc básicos” que se encontra 
normalmente nos conteúdos gratuitos em nosso idioma. 
Como mencionado anteriormente, está apostila pode ser impressa e tomada como 
auxilio de qualquer curso voltado a tecnologia abordado aqui, desde que não se 
cobre nada por ela e que seus autores sejam devidamente mencionados e 
creditados. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Sumário .............................. 7 
Configurando Player Character ............................................................................................. 8 
Configurações Iniciais ........................................................................................................ 9 
Axis e Action Mappings .................................................................................................... 16 
Animation Blueprint ......................................................................................................... 31 
Blend Space 1D ................................................................................................................ 36 
Editando Animações ........................................................................................................ 43 
Configurando Animação de Pulo ...................................................................................... 46 
Conclusão ........................................................................................................................ 49 
Configurando Player Character ........................................................................................... 51 
Configurações Iniciais ...................................................................................................... 53 
Axis e Action Mappings .................................................................................................... 60 
Game Mode ..................................................................................................................... 63 
Configurando Movimento................................................................................................. 66 
Animation Blueprint ......................................................................................................... 72 
Blend Space 1D ................................................................................................................ 77 
Editando Animações ........................................................................................................ 83 
Configurando Animação de Pulo ...................................................................................... 87 
Conclusão ........................................................................................................................ 90 
Adicionando Animações ...................................................................................................... 91 
Template do projeto ......................................................................................................... 92 
Adicionando Animações Com Animation Motage ............................................................101 
Inteligência Artificial I ........................................................................................................111 
Template do projeto ........................................................................................................112 
Configurando a IA ...........................................................................................................113 
Programando a IA ...........................................................................................................116 
Questão: ..........................................................................................................................117 
Área de atuação “Nav Mesh”...........................................................................................117 
Conclusão .......................................................................................................................119 
Aguçando a curiosidade ..................................................................................................119 
Inteligência Artificial II .......................................................................................................120 
Template do projeto ........................................................................................................121 
Lista de Passos: ...............................................................................................................121 
Organizando os diretórios ...............................................................................................122 
Sistema Chave&Porta / Pontuação I .................................................................................124 
 
Criando a porta ...............................................................................................................128 
O elevador ......................................................................................................................130 
Controle de estados ........................................................................................................131 
Programação no Player (Jogador) ...................................................................................132 
Sistema Chave Porta / Pontuação II .................................................................................132 
Chaves ............................................................................................................................133 
Portas ..............................................................................................................................133 
Elevador .........................................................................................................................135 
Checkpoint .....................................................................................................................136 
Zona da morte .................................................................................................................137 
O inimigo (IA) .................................................................................................................138 
Subindo níveis! ................................................................................................................142 
Inteligência Artificial III ......................................................................................................145 
Template do projeto ........................................................................................................146Lista de Passos: ...............................................................................................................146 
Configuração inicial do projeto .......................................................................................147 
Game design ...................................................................................................................149 
Qual estado eu início .......................................................................................................150 
Resumo de funções e variáveis ........................................................................................151 
Existe algum player próximo de mim? ............................................................................153 
Onde está o player onde irei me posicionar? ..................................................................156 
A que distância do player devo ficar em guarda? Ou sair da guarda? .............................160 
Quando que eu posso atacar? ..........................................................................................160 
Introdução a interface Gráfica ............................................................................................167 
Configurações Iniciais .....................................................................................................169 
GUI ..................................................................................................................................169 
Sistema de Health ............................................................................................................176 
Criando Regenerador de Health .....................................................................................180 
Conclusão ...........................................................................................................................183 
Referência Bibliográfica ......................................................................................................184 
 
Sumário 
 
 
 
 
 
 
 
 
 
 
Configurando Player Character 
Third Person 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurando Player Character 
Third Person 
Neste capítulo veremos como configurar um personagem jogável a partir de um 
projeto Blank da Engine Unreal 4, convertendo o projeto para a jogabilidade Third 
Person. Iremos definir seus controles de interação bem como suas animações de 
resposta. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurações Iniciais 
Como dito anteriormente, este projeto terá como base um template Blank, com isso 
selecione este template, certifique-se de estar na aba Blueprint, e não C++. 
 
 
Após o Unreal Editor ter iniciadocrie uma pasta para o personagem que você deseja 
trazer, dentro desta paste crie mais 3 pastas, para Textura, Material e Animação. 
Feito isso clique no botão Import localizado no menu Content Browser. 
 
Traga o modelo 3D do personagem que deseja configurar. É importante certificar-se 
que este modelo possua esqueleto, caso contrário não será possível atrelar as 
animações a ele. 
 
 
 
Este painel possui configurações de importação, ele é dividido em 4 abas: 
Configurações de Mesh; Animação; Transformação e Materal. Não faremos 
alterações neste menu para o nosso personagem, mas caso você queira trazer 
animações junto do mesh marque Import Animations, para alterar a escala do 
personagem caso ele venha muito pequeno ou muito grande para Engine reimporte 
e configure Import Uniform Scale. Caso você prefira configurar o material, do zero, 
dentro da Unreal, desmarque Import Materials ou Import Textures. 
 
Além do mesh mais 2 arquivos são importados Physics Assets e o Skeleton. Caso seu 
modelo tenha vindo com muitos materiais e texturas soltos organize-os nas pastas 
correspondentes. Depois do mesh importado e organizado iremos agora criar uma 
Classe Blueprint do tipo Character. Para isso clique com o botão direito do mouse 
num espaço vazio dentro da pasta do Player, e escolha a opção Blueprint Class. 
 
 
Após informar que queremos criar uma nova classe Blueprint devemos agora 
escolher qual tipo de classe queremos criar. Interagiremos agora com o painel Pick 
Parent Class, para nosso player devemos escolher Character. 
 
Nomeie a nova classe como quiser, uma dica é colocar as siglas BP depois do nome 
escolhido para identificar com facilidade no futuro, que se trata de uma classe 
Blueprint. 
 
Vamos agora configurar nosso Player Blueprint, clique duas vezes no seu ícone para 
abrirmos o editor. 
 
 
 
 
No painel Components clique na opção Mesh. Agora vá 
no painel Details (a direita) e na aba Mesh abara as 
opções clicando na seta ao lado de None. Escolha o 
modelo 3D do player que você acabou de importar. 
 
 
 
Normalmente ele vem rotacionado de forma diferente das configurações do player, 
para posicioná-lo de forma correta basta girar o mesh até o lado da frente dele 
 
respeitar a direção que o ArrowComponent aponta, -90 graus no eixo Z no nosso 
exemplo. 
 
Depois disso é interessante fazer o mesh do personagem respeitar a altura da 
capsula, suba-o até que seus pés fiquem dentro da base da capsula. 
 
Agora vamos adicionar 2 componentes essenciais para nosso Player. Clique no botão 
verde Add Component, fica no topo do painel Component. Procure por “ApringArm” 
e clique nele para adicionar. 
 
 
Agora procure por Camera para adicionar este componente também. 
 
O SpringArm é responsável por regular a distância da câmera para o Player com isso 
a câmera deve estar atrelada a ele. Para atrelarmos a câmera aqui devemos torna-la 
“Child” do SpringArm, arraste a câmera até o SrpingArm e solte nele para isso. Note 
que depois disso a câmera foi sozinha até a outra extremidade do SpringArm. 
 
Feito isso clique em SrpingArm e no painel Details marque a opção “Use Pawn 
Control Rotation”. Essa opção nos garantirá um funcionamento correto da rotação 
do player, depois de empregarmos os devidos códigos de movimento e rotação 
faremos outras configurações por aqui. 
Feito isso definimos a aparência de nosso Player Character, agora precisamos definir 
seus controles e em seguida configurar as animações. 
 
No Level Editor, clique em Edit e depois em Project Settings. 
 
 
Axis e Action Mappings 
Dentro de Project Settings procure do lado esquerdo a opção Input, ela é um dos 
itens pertencentes a aba Engine. 
 
Agora na opção Bindings nós definimos os mecanismos básicos de interação de 
nosso jogo com as teclas e botões de nossos controles. 
 
 
O que são AXIS e ACTION MAPPINGS? 
Toda ação que o nosso player faz, depende de interações com botões, nós podemos 
setar diretamente na Event Graph do Player a Barra de Espaço para pular e o botão 
W para correr, ou X do controle para atacar, mas como forma de dinamizar as 
definições e padrões de nossos controles, é possível criar aqui na aba Bindings os 
comandos gerais, e mais tarde instanciá-los como Nós Blueprints para definirmos os 
códigos. Isso facilita nossa vida de várias formas, uma delas é caso o nosso game 
tenha múltiplos players, as definições básicas de movimento e câmera que serão as 
mesmas para todos podem ser criadas aqui, e nó Event Graph de cada criaríamos 
apenas interações singulares com outros botões. 
O mapeamento de Axis, trabalha interações que dependem de um eixo para ocorrer, 
como o movimento do personagem e da câmera, permitem entradas que têm um 
alcance contínuo. Já as interações Actions são para pressionamentos de teclas e 
lançamentos, ou seja nãosão continuas. 
Clique 1 vez no + ao lado de Axis Mappings, note que surgiu uma seta ao lado 
esquerdo. 
 
 
Clicando nela acessamos um sub menu. 
 
 
 
Agora temos um caixa com o texto “NewAxisMapping”, e abaixo dela temos um menu 
onde é possível escolher teclas para diferentes tipos de interação. Renomeie o texto 
da caixa para um texto correspondente aos movimentos de “ir para frente e ir para 
trás” e escolha a tecla do teclado correspondente ao movimento de “frente”. 
 
A tecla “W” no teclado foi definida como interação de ir para frente, mas o texto do 
comando diz “FrenteTras” então precisamos de outra tecla que fará o comando 
contrário, para atribuirmos outra tecla a este evendo clicamos no símbolo +, dessa 
vez ao lado da caixa de texto que digitamos “FrenteTrasCMD”. 
 
 
Agora poderemos atribuir mais uma tecla a esta função, usaremos o “S” e para 
garantir que ao apertamos ele o personagem vá para trás deveremos colocar o valor 
negativo em Scale. 
 
 
Dessa forma ao apertamos “S” pegaremos os mesmos valores dos futuros códigos 
que atribuiremos a este evento (FrenteTrasCMD) porém esses valores serão 
negativos. Para adicionar mais Axis Mappings clique mais uma vez no símbolo + ao 
lado de Axis Mappings. Precisaremos de mais 3 eventos de interação e um Action 
Mapping. 
 
 
Conclua repetindo este esquema. 
 
 
Nós acabamos de definir Eventos de interação com os controles do jogo (no caso 
teclado e mouse) esses eventos serão validados quando fazermos a devida interação 
deles com os comandos Blueprints responsáveis pelo deslocamento do personagem. 
 
Antes de irmos para esse passo, vamos criar outra Classe Blueprint denominada 
GameMode. 
 
Game Mode 
 
O GameMode é responsável por algumas definições importantes em nosso projeto, 
uma delas é justamente a definição de quem é personagem que iremos controlar. 
Para criar um novo GameMode clique na opção Blueprints na Toolbar e siga o 
caminho mostrado na figura abaixo. 
 
Nomeie o novo GameMode como desejar e coloque-o em uma paste adequada nesta 
etapa da configuração. 
 
 
No GameMode Editor vá ao painel Detail, mais precisamente a opção Depauf Pawn 
Class. 
 
Após encontrar o nome que você colocou no seu Player clique nele definindo-o como 
o “protagonista” do jogo. 
Para que este GameMode funcione em sua fase você deve voltar ao Level Editor e ir 
no Menu World Settings. 
 
Ele fica em outra aba ao lado do painel Details. 
 
 
 
Na opção GameMode Override, clique e escolha o GameMode que você acabou de 
criar. 
 
Caso queira que este mesmo GameMode funcione em todas as fases do seu game de 
uma vez só, sem precisar ficar fazendo essa configuração no World Settings, vá ao 
Project Settings e clique em Maps Modes, ele é uma das opções de Projct. 
 
Certifique-se de que o seu GameMode esteja na Aba Defaut GameMode. 
 
 
Agora retorne ao Editor do nosso PlayerBP. 
Configurando Movimento 
 
 
 
Caso você veja essa expansão de Class Defauts ao abrir a classe Blueprint do Player, 
e queira voltar a visualizar o Editor da forma padrão, basta clicar no texto azul “Open 
“Full Blueprint Editor” localizado no topo da aba. 
Vamos agora para a Aba Event Graph. 
 
 
Selecione e delete esses nós nativos. Depois clique com o botão direito e traga os 
events Axis e Action que criamos, basta digitar o nome que demos a eles. 
 
Vamos configurar primeiro a interação FrenteTrasCMD. Precisaremos de um nó Add 
Moviment Input, para dizermos que este evento agora interagirá com os inputs de 
movimentação. 
 
 
Precisamos de um Vector como retorno de World Direction, o nó Get Forward Vector 
justamente trabalha nas direções correspondente, frente e trás. 
 
 
 
Fazemos dele a condição de World Direction. Lembre-se de compilar e salvar. 
 
 
Podemos testar nosso comando agora se quisermos e ao jogar o player na cena ao 
apertamos as teclas que escolhemos para FrenteTrasCMD, vamos o personagem se 
mover para frente e para trás. 
 
Caso não esteja funcionando corretamente retorne ao passe anterior e confira os 
nomes dos Nós e suas Ligações. 
Agora voltemos para o Event Graph do nosso Player e vamos configurar os 
movimentos de esquerda e direita. 
 
 
Repita o nó Add Moviment Input mas dessa vez o Vector trabalhará os valores de 
esquerda e direita, com isso escolheremos o nó Get Right Vector. Se dermos play na 
nossa fase agora, além de se mover para a frente e para trás o personagem se moverá 
para esquerda e direita também. 
Mas ele não está girando em seu eixo quando o movemos. Para que ele faça isso 
devemos clicar no Self do nosso player, que fica no topo do menu Components. 
 
Depois vamos desmarcar Use Control Rotation YAW, no painel Detail. 
 
 
Voltando ao Painel Components, dessa vez vamos em CharacterMoviment. Depois 
de clicar nesta opção procure no painel Details a opção Orient Rotation To 
Movement e marque. 
 
 
Agora ao dar play no Level nós podemos ver que o personagem gira respeitando o 
caminho que fazemos. 
 
Agora para a câmera... 
 
 
Tudo certo... Porém há alguma coisa errada com a rotação do player, será que você 
consegue identificar? 
Ao posicionarmos a câmera e apertamos para o player seguir, sua orientação 
permanece a mesma de quando o Level foi iniciado, ou seja, ele não respeita a 
orientação da câmera para mudar de direção, isso não deixa a jogabilidade muito 
atrativa. 
Para concertar isso precisamos unir os dois Vector, que são as funções de retorno de 
nossos eventos Axis a um Get Control Rotation. 
 
Utilizaremos os nós Make rotation e Break Rotation como intermediários, ligados 
pela rotação no eixo YAW 
 
 
Vamos agora testar se ao rotacionalrmos a câmera o player segue as novas direções 
que a câmera determinar como frente, costas e esquerda e direita... 
 
Ótimo, agora vamos configurar os comandos do pulo. Basta adicionar o nó Jump e 
Stop jump ao evento que criamos. 
 
 
 
Perfeito! Nosso player se move para todos os lados, pula e sua câmera orienta seu 
eixo de movimentação, e também se move bem nos eixos determinados, agora 
podemos passar pra o próximo passo, configurar as animações. 
Animation Blueprint 
Importe as animações correspondentes ao seu player, elas têm de ter Idle (animação 
onde o personagem encontra-se de pé em repouso), andar, correr saltar e caindo. 
Na hora de importar a animação marque o Skeleton como o do seu player. 
 
 
Com as animações em sua devida pasta, iremos agora criar um Animation Blueprint. 
 
 
Para criarmos um Animation Blueprint clique com o botão direito em um espaço 
vazio do Content Browser e siga o caminho ilustrado abaixo. 
 
Nesta próxima opção definimos o esqueleto do personagem, AnimStance e clicamos 
em OK. 
 
 
 
 
Este é Anim Editor devemos criar um novo Estado de Animação para 
prosseguirmos. Clique com o botão direito do mouse e digite Add New State 
Machine. 
 
Renomeie o novo State Machine como achar melhor e faça a ligação demonstrada 
abaixo. 
 
 
Clique duas vezes no State Machine que você adicionou para entrar em outra camada 
da edição de animações. 
 
O nó Entry define o estado primário da animação, tudo que ligarmos a ele será 
imediatamente executado. Vamos fazer um pequeno teste. Note que na aba abaixo 
denominada Asset Bowser estão listadas todas as animações que importamos para 
este personagem. Clique em uma delas e arraste até ao lado de Entry. 
Agora puxe uma ligação de Entry até o nó que contém a animação que arrastamos. 
 
 
Para testarmos nosso Animation Blueprintprecisamos selecioná-lo no Blueprint de 
nosso player, então vamos compilar e salvar essa animação e abrir o PlayerBP. 
Clique no Mesh do player na aba Components, depois no painel Details procure Anim 
Class. 
 
 
 
Procure na lista que aparece o Animation Blueprint que você criou e clique nele para 
definí-lo para seu personagem. 
Repare que assim que fazemos isso o personagem incorpora automaticamente a 
animação que ligamos ao nó Entry. 
 
 
Caso dermos Player em nosso jogo agora, notamos que, não iporta qual comando 
dermos o personagem responderá a todos com a mesma animação. Isso não é 
interessante para nosso projeto, então vamos prosseguir para o próximo passo. 
Entendemos agora como funciona a interação de animações com o Entry. 
Precisamos agora fazer com que o personagem produza animações mais realistas 
de respostas, como ficar parado quando não o movemos e dobrar os joelhos e 
impulsionar-se para cima quando apertamos o comando de pular. Para o primeiro 
exemplo precisamos criar um Blad Space 1D. 
 
Blend Space 1D 
Clique com o botão direito no Content Browser e siga mais uma vez a imagem abaixo 
para criar um Blend Space 1D 
Blend Spaces são Assets especiais que permitem um arranjo e mistura de 
animações com base nos valores de duas entradas. A mistura simples entre duas 
animações com base em uma única entrada pode ser realizada usando um dos nós 
de mistura padrão disponíveis em Animation Blueprints. Os Blend Spaces fornecem 
um meio de fazer misturas mais complexas 
entre várias animações baseadas em múltiplos valores. 
 
 
 
 
Para configurarmos nossa Mistura de animações precisamos colocar uma animção 
para o estado zero e outra em outro ponto em que o personagem aumente sua 
velocidade. 
 
 
Nomeie o BlendSpace levando em conta que haverão trnasições de 
estados de animação, como Parado, andando e correndo, é sempre 
bom deixar uma pista no texto que nomamos nossas classes, do que 
essas se tratam. 
 
Vamos arrastar a animação de Idle do Asset Browser até o marco 0 na linha de 
transição. 
 
Agora vamos colocar a animação em que personagem corre no marco 100. 
 
Note que transitar o mouse entre os 2 estados vemos a transição suave dos 
mesmos. Agora criamos uma animação de transição, para que o nosso personagem 
saia do estado repouso para o movimento de forma mais agradável aos nossos 
olhos. 
Precisamos agora voltar ao Animation Blueprint para configurarmos corretamente 
nosso Blend Space lá. Salve e abra o Animation. 
 
 
Delete esse nó que ligamos a Entry, como teste. E agora arraste nossa recém-criada 
Blend Space 1D para essa mesma ligação. 
 
Clique 2 vezes para acessar o nó que contém nosso BlendSpace 1D. 
Nós vemos agora um nó que representa uma instancia de nosso BlendSpace 1D, ele 
contém uma condição None, que possui um zero, seguido de uma vírgula e um 
monte de outros zeros. Vamos entender de que forma essa condição influencia na 
nossa BlendSpace 1D? lembra que lá colocamos a animação Idle no marco 0 e 
correr no marco 100? Então veja o que acontece com a figura do seu player quando 
digitamos 100 na condição None e compilamos. 
 
 
O personagem no topo esquerdo agora corre. Isso acontece pois acabamos de 
acessar aquela reta da Blend Space 1D. O processo que vamos iniciar agora nos 
garantirá que essa mesma reta seja acessada por nossos botões de interação. 
Crie uma variável Float com o nome “Velocidade” e a arraste pra cena a conectando 
como condição de nossa BlendSpace1D. 
 
Agora vamos na aba ao lado EventGraph. 
 
 
Arraste a variável, dessa vez como Set, e faça a seguinte ligação. 
 
Para acessarmos os Inputs do personagem precisamos dos nós Get Velocity e 
Vector Lengh, arraste uma ligação de Try Get Pawn Owner e chame um nó depois o 
outro. 
 
 
Vamos agora testar no game nosso progresso. 
 
Perfeito! 
Agora vamos a animação de Pulo. 
Voltemos para Animation BP. 
 
 
 
 
 
Editando Animações 
 
 
Precisamos criar um esquema com 3 animação para o pulo, uma animação de início 
de pulo, outra para quando o personagem estiver em queda e outra com o final do 
pulo, porém temos no exemplo 2 animações de pulo, uma em que o personagem 
inicia um pouco antes do salto e termina um pouco depois de pousar no chão, e 
outra em que o personagem está caindo até que encontra o chão. Nós temos então 
de editar estas duas animações para funcionarem corretamente dentro de nosso 
esquema. Para isso vá até a pasta de animações e duplique a animação de Pulo. 
 
Clique 2 vezes para editar a do início. 
Pause a animação para trabalhar melhor. Posicione a barra vermelha manualmente 
um pouco antes do personagem tirar os pés do chão, pouquíssimos frames antes. 
 
 
Clique com o botão direito sobre a posição escolhida e apague os frames iniciais. 
 
Mova manualmente a barrinha vermelha até um pouco depois que os pés saem do 
chão, e apague os frames depois da marcação atual. 
 
 
Salve e pronto temos o início do nosso pulo. Vamos abrir agora a próxima animação, 
Pulo Final. 
Dessa vez mova os frames até antes dos pés retornarem ao chão, e apague os 
anteriores. 
 
Depois que ele encostar no chão e dobrar um pouquinho os joelhos apague os frames 
seguintes. 
 
 
Salve. Caso a animação de queda precise de edição faça também. 
 
Configurando Animação de Pulo 
Vamos agora voltar ao Animation Blueprint. 
 
Arraste as 3 animações para ficarem nesse esquema mostrado. Agora vamos fazer 
as ligações entre esses estados, começando do Bland Space 1D para Pulo_inicio e 
terminando de Pulo_Final a Bland Space 1D. 
 
 
Note que agora nossas ligações possuem um círculo branco no meio, é ai que 
definiremos a condição de transição do pulo, e parte do processo de interação com 
os controladores. 
Clique 2 vezes no círculo entre a Bland Space 1D e Pulo_inicio. 
 
Devemos aqui criar uma variável Bolean que indique se o pulo é verdadeiro ou falso. 
 
 
Repita os seguintes esquemas respectivamente para os próximos nós. 
 
Antes de irmos para o próximo passo certifique-se de que todas as animações não 
estão em Loop. Clique duas vezes em cada um dos nós das animações da sequência 
de pulo e desmarque Loop Animator. Repita isso nas 3 animações de pulo. 
, 
 
 
 
 
Conclusão 
Agora vamos ao EventGraph e fazemos o seguinte esquema para acessarmos a 
animação de pulo corretamente ao apertar a Barra de Espaço no game. 
 
Vamos ao teste. 
 
 
 
Perfeito! 
 E assim concluímos nossas configurações básicas para um Player de um prjeto 
Third Person. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurando Player Character 
Side Scroller 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurando Player Character 
Side Scroller 
Neste capítulo veremos como configurar um personagem jogável a partir de um 
projeto Blank da Engine Unreal 4, convertendo o projeto para a jogabilidade Side 
Scroller. Iremos definir seus controles de interação bem como suas animações de 
resposta. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurações Iniciais 
Como dito anteriormente, este projeto terá como base um template Blank, com isso 
selecione este template, certifique-se de estar na aba Blueprint, e não C++. 
 
Após o Unreal Editor ter iniciadocrie umapasta para o personagem que você deseja 
trazer, dentro desta paste crie mais 3 pastas, para Textura, Material e Animação. 
Feito isso clique no botão Import localizado no menu Content Browser. 
 
Traga o modelo 3D do personagem que deseja configurar. É importante certificar-se 
que este modelo possua esqueleto, caso contrário não será possível atrelar as 
animações a ele. 
 
 
 
Este painel possui configurações de importação, ele é dividido em 4 abas: 
Configurações de Mesh; Animação; Transformação e Materal. Não faremos 
alterações neste menu para o nosso personagem, mas caso você queira trazer 
animações junto do mesh marque Import Animations, para alterar a escala do 
personagem caso ele venha muito pequeno ou muito grande para Engine reimporte 
e configure Import Uniform Scale. Caso você prefira configurar o material, do zero, 
dentro da Unreal, desmarque Import Materials ou Import Textures. 
 
Além do mesh mais 2 arquivos são importados Physics Assets e o Skeleton. Caso seu 
modelo tenha vindo com muitos materiais e texturas soltos organize-os nas pastas 
correspondentes. Depois do mesh importado e organizado iremos agora criar uma 
Classe Blueprint do tipo Character. Para isso clique com o botão direito do mouse 
num espaço vazio dentro da pasta do Player, e escolha a opção Blueprint Class. 
 
 
Após informar que queremos criar uma nova classe Blueprint devemos agora 
escolher qual tipo de classe queremos criar. Interagiremos agora com o painel Pick 
Parent Class, para nosso player devemos escolher Character. 
 
Nomeie a nova classe como quiser, uma dica é colocar as siglas BP depois do nome 
escolhido para identificar com facilidade no futuro, que se trata de uma classe 
Blueprint. 
 
 
Vamos agora configurar nosso Player Blueprint, clique duas vezes no seu ícone para 
abrirmos o editor. 
 
 
 
No painel Components clique na opção Mesh. Agora vá 
no painel Details (a direita) e na aba Mesh abara as 
opções clicando na seta ao lado de None. Escolha o 
modelo 3D do player que você acabou de importar. 
 
 
 
Normalmente ele vem rotacionado de forma diferente das configurações do player, 
para posicioná-lo de forma correta basta girar o mesh até o lado da frente dele 
respeitar a direção que o ArrowComponent aponta, -90 graus no eixo Z no nosso 
exemplo. 
 
Depois disso é interessante fazer o mesh do personagem respeitar a altura da 
capsula, suba-o até que seus pés fiquem dentro da base da capsula. 
 
 
Agora vamos adicionar 2 componente essenciais para nosso Player. Clique no botão 
verde Add Component, fica no topo do painel Component. Procure por “ApringArm” 
e clique nele para adicionar. 
 
Agora procure por Camera para adicionar este componente também. 
 
O ApringArm é responsável por regular a distância da câmera para o Player com isso 
a câmera deve estar atrelada a ele. Para atralarmos a câmera aqui devemos torna-la 
“Child” do ApringArm, arraste a câmera até o Srping Arm e solte nele para isso. Note 
que depois disso a câmera foi sozinha até a outra extremidade do ApringArm. 
 
 
Feito isso clique em SrpingArm e no painel Details marque a opção “Use Pawn 
Control Rotation”. Vamos fazer mais 2 configurações agora. Ainda no painel Detail, 
vamos inverter a posição da câmera para com o player aumentar a altura do braço, 
ponha - 500 em Target Arm Length e em target Offset marcamos 150 somente no 
eixo Z, isso erguerá um pouco o SpringArm. 
 
Agora vamos clicar na Camera, lá no painel Components, para ajustar sua visão do 
player. No seu painel Detail em Rotation eixo y vamos colocar o valor 334, isso fará 
com que ela se centralize no Player. 
Feito isso definimos a aparência de nosso Player Character, agora precisamos definir 
seus controles e em seguida configurar as animações. 
No Level Editor, clique em Edit e depois em Project Settings. 
 
 
 
Axis e Action Mappings 
Dentro de Project Settings procure do lado esquerdo a opção Input, ela é um dos 
itens pertencentes a aba Engine. 
 
Agora na opção Bindings nós definimos os mecanismos básicos de interação de 
nosso jogo com as teclas e botões de nossos controles. 
 
 
O que são AXIS e ACTION MAPPINGS? 
Toda ação que o nosso player faz, depende de interações com botões, nós podemos 
setar diretamente na Event Graph do Player a Barra de Espaço para pular e o botão 
W para correr, ou X do controle para atacar, mas como forma de dinamizar as 
definições e padrões de nossos controles, é possível criar aqui na aba Bindings os 
comandos gerais, e mais tarde instanciá-los como Nós Blueprints para definirmos os 
códigos. Isso facilita nossa vida de várias formas, uma delas é caso o nosso game 
tenha múltiplos players, as definições básicas de movimento e câmera que serão as 
mesmas para todos podem ser criadas aqui, e nó Event Graph de cada criaríamos 
apenas interações singulares com outros botões. 
O mapeamento de Axis, trabalha interações que dependem de um eixo para ocorrer, 
como o movimento do personagem e da câmera, permitem entradas que têm um 
alcance contínuo. Já as interações Actions são para pressionamentos de teclas e 
lançamentos, ou seja não são continuas. 
Clique 1 vez no + ao lado de Axis Mappings, note que surgiu uma seta ao lado 
esquerdo. 
 
 
Clicando nela acessamos um sub menu. 
 
 
 
Agora temos um caixa com o texto “NewAxisMapping”, e abaixo dela temos um menu 
onde é possível escolher teclas para diferentes tipos de interação. Renomeie o texto 
da caixa para um texto correspondente aos movimentos de “ir para Direita e ir para 
Esquerda” e escolha a tecla do teclado correspondente ao movimento de “Direita”. 
 
A tecla “D” no teclado foi definida como interação de ir para direita, mas o texto do 
comando diz “DirEsqMov” então precisamos de outra tecla que fará o comando 
contrário, para atribuirmos outra tecla a este evendo clicamos no símbolo +, dessa 
vez ao lado da caixa de texto que digitamos “DirEsqMov”. 
 
Agora poderemos atribuir mais uma tecla a esta função, usaremos o “A” e para 
garantir que ao apertamos este botão o personagem vá para esquerda deveremos 
colocar o valor negativo em Scale. 
Dessa forma ao apertamos “A” pegaremos os mesmos valores dos futuros códigos 
que atribuiremos a este evento (DirEsqMov) porém esses valores serão negativos. 
 
 
Conclua repetindo este esquema. 
 
 
Nós acabamos de definir Eventos de interação com os controles do jogo (no caso 
teclado e mouse) esses eventos serão validados quando fazermos a devida interação 
deles com os comandos Blueprints responsáveis pelo deslocamento do personagem. 
Antes de irmos para esse passo, vamos criar outra Classe Blueprint denominada 
GameMode. 
 
 
Game Mode 
O GameMode é responsável por algumas definições importantes em nosso projeto, 
uma delas é justamente a definição de quem é personagem que iremos controlar. 
Para criar um novo GameMode clique na opção Blueprints na Toolbar e siga o 
caminho mostrado na figura abaixo. 
 
 
Nomeie o novo GameMode como desejar e coloque-o em uma paste adequada nesta 
etapa da configuração. 
 
No GameMode Editor vá ao painel Detail, mais precisamente a opção Depauf Pawn 
Class. 
 
Após encontrar o nome que você colocou no seu Player clique nele definindo-o como 
o “protagonista” do jogo. 
Para que este Game Mode funcione em sua fase você deve voltar ao Level Editor e ir 
no Menu World Settings. 
 
 
Ele fica em outra aba ao lado do painel Details. 
 
 
Na opção GameMode Override, clique e escolha o GameMode que você acabou de 
criar. 
 
Caso queira que este mesmo GameMode funcione em todas as fases do seu game de 
uma vez só, sem precisar ficar fazendo essa configuraçãono World Settings, vá ao 
Project Settings e clique em Maps Modes, ele éuma das opções de Projct. 
 
 
Certifique-se de que o seu GameMode esteja na Aba Defaut GameMode. 
 
Agora retorne ao Editor do nosso PlayerBP. 
Configurando Movimento 
 
 
 
Caso você veja essa expansão de Class Defauts ao abrir a classe Blueprint do Player, 
e queira voltar a visualizar o Editor da forma padrão, basta clicar no texto azul “Open 
“Full Blueprint Editor” localizado no topo da aba. 
Vamos agora para a Aba Event Graph. 
 
Selecione e delete esses nós nativos. Depois clique com o botão direito e traga os 
events Axis e Action que criamos, basta digitar o nome que demos a eles. 
 
 
Vamos configurar primeiro a interação DirEsqMov. Precisaremos de um nó Add 
Moviment Input, para dizermos que este evento agora interagirá com os inputs de 
movimentação. Em World Direction adicione o valor de - 1.0 a Y. 
 
 
Podemos testar nosso comando agora se quisermos e ao jogar o player na cena ao 
apertamos as teclas que escolhemos para DirEsqMov, vamos o personagem se 
mover para direita e para esquerda. 
 
 
Caso não esteja funcionando corretamente retorne ao passe anterior e confira os 
nomes dos Nós e suas Ligações. 
Mas ele não está girando em seu eixo quando o movemos. Para que ele faça isso 
devemos clicar no Self do nosso player, que fica no topo do menu Components. 
 
Depois vamos desmarcar Use Control Rotation YAW, no painel Detail. 
 
 
Voltando ao Painel Components, dessa vez vamos em CharacterMoviment. Depois 
de clicar nesta opção procure no painel Details a opção Orient Rotation To 
Movement e marque. 
 
 
Agora ao dar play no Level nós podemos ver que o personagem gira respeitando o 
caminho que fazemos. 
Ótimo, agora vamos configurar os comandos do pulo. Basta adicionar o nó Jump e 
Stop jump ao evento que criamos. 
 
 
 
Perfeito! Nosso player se move para direita e esquerda e pula! Agora podemos 
passar para o próximo passo, configurar as animações. 
Animation Blueprint 
Importe as animações correspondentes ao seu player, elas têm de ter Idle (animação 
onde o personagem encontra-se de pé em repouso), andar, correr saltar e caindo. 
Na hora de importar a animação marque o Skeleton como o do seu player. 
 
 
Com as animações em sua devida pasta, iremos agora criar um Animation Blueprint. 
 
 
 
Para criarmos um Animation Blueprint clique com o botão direito em um espaço 
vazio do Content Browser e siga o caminho ilustrado abaixo. 
 
Nesta próxima opção definimos o esqueleto do personagem, AnimStance e clicamos 
em OK. 
 
 
 
 
Este é Anim Editor devemos criar um novo Estado de Animação para 
prosseguirmos. Clique com o botão direito do mouse e digite Add New State 
Machine. 
 
Renomeie o novo State Machine como achar melhor e faça a ligação demonstrada 
abaixo. 
 
Clique duas vezes no State Machine que você adicionou para entrar em outra camada 
da edição de animações. 
 
 
O nó Entry define o estado primário da animação, tudo que ligarmos a ele será 
imediatamente executado. Vamos fazer um pequeno teste. Note que na aba abaixo 
denominada Asset Bowser estão listadas todas as animações que importamos para 
este personagem. Clique em uma delas e arraste até ao lado de Entry. 
Agora puxe uma ligação de Entry até o nó que contém a animação que arrastamos. 
 
Para testarmos nosso Animation Blueprint precisamos selecioná-lo no Blueprint de 
nosso player, então vamos compilar e salvar essa animação e abrir o PlayerBP. 
Clique no Mesh do player na aba Components, depois no painel Details procure Anim 
Class. 
 
 
 
 
Procure na lista que aparece o Animation Blueprint que você criou e clique nele para 
definí-lo para seu personagem. 
Repare que assim que fazemos isso o personagem incorpora automaticamente a 
animação que ligamos ao nó Entry. 
 
Caso dermos Player em nosso jogo agora, notamos que, não iporta qual comando 
dermos o personagem responderá a todos com a mesma animação. Isso não é 
interessante para nosso projeto, então vamos prosseguir para o próximo passo. 
Entendemos agora como funciona a interação de animações com o Entry. 
Precisamos agora fazer com que o personagem produza animações mais realistas 
de respostas, como ficar parado quando não o movemos e dobrar os joelhos e 
impulsionar-se para cima quando apertamos o comando de pular. Para o primeiro 
exemplo precisamos criar um Blad Space 1D. 
 
 
 
 
 
Blend Space 1D 
Clique com o botão direito no Content Browser e siga mais uma vez a imagem abaixo 
para criar um Blend Space 1D 
Blend Spaces são Assets especiais que permitem um arranjo e mistura de 
animações com base nos valores de duas entradas. A mistura simples entre duas 
animações com base em uma única entrada pode ser realizada usando um dos nós 
de mistura padrão disponíveis em Animation Blueprints. Os Blend Spaces 
fornecem um meio de fazer misturas mais complexas 
entre várias animações baseadas em múltiplos valores. 
 
 
 
Para configurarmos nossa Mistura de animações precisamos colocar uma animção 
para o estado zero e outra em outro ponto em que o personagem aumente sua 
velocidade. 
 
Nomeie o BlendSpace levando em conta que haverão trnasições de 
estados de animação, como Parado, andando e correndo, é sempre 
bom deixar uma pista no texto que nomamos nossas classes, do qu e 
essas se tratam. 
 
 
Vamos arrastar a animação de Idle do Asset Browser até o marco 0 na linha de 
transição. 
 
Agora vamos colocar a animação em que personagem corre no marco 100. 
 
 
Note que transitar o mouse entre os 2 estados vemos a transição suave dos 
mesmos. Agora criamos uma animação de transição, para que o nosso personagem 
saia do estado repouso para o movimento de forma mais agradável aos nossos 
olhos. 
Precisamos agora voltar ao Animation Blueprint para configurarmos corretamente 
nosso Blend Space lá. Salve e abra o Animation. 
 
Delete esse nó que ligamos a Entry, como teste. E agora arraste nossa recém criada 
Blend Space 1D para essa mesma ligação. 
 
 
Clique 2 vezes para acessar o nó que contém nosso BlendSpace 1D. 
Nós vemos agora um nó que representa uma instancia de nosso BlendSpace 1D, ele 
contem uma condição None, que possui um zero, seguido de uma vírgula e um 
monte de outros zeros. Vamos entender de que forma essa condição influencia na 
nossa BlendSpace 1D? lembra que lá colocamos a animação Idle no marco 0 e 
correr no marco 100? Então veja o que acontece com a figura do seu player quando 
digitamos 100 na condição None e compilamos. 
 
O personagem no topo esquerdo agora corre. Isso acontece pois acabamos de 
acessar aquela reta da Blend Space 1D. O processo que vamos iniciar agora nos 
garantirá que essa mesma reta seja acessada por nosso botões de interação. 
Crie uma variável Float com o nome “Velocidade” e a arraste pra cena a conectando 
como condição de nossa BlendSpace1D. 
 
 
Agora vamos na aba ao lado EventGraph. 
 
Arraste a variável, dessa vez como Set, e faça a seguinte ligação. 
 
 
Para acessarmos os Inputs do personagem precisamos dos nós Get Velocity e 
Vector Lengh, arraste uma ligação de Try Get Pawn Owner e chame um nó depois o 
outro. 
 
Vamos agora testar no game nosso progresso. 
 
 
Perfeito! 
Agora vamos a animação de Pulo. 
Voltemos para Animation BP. 
Editando Animações 
 
 
 
Precisamos criar um esquema com 3 animação para o pulo, uma animação de inicio 
de pulo, outra para quando o personagem estiver em queda e outra com o final do 
pulo, porém temos no exemplo 2 animaçõesde pulo, uma em que o personagem 
incia um pouco antes do salto e termina um pouco depois de pousar no chão, e 
outra em que o personagem está caindo até que encontra o chão. Nós temos então 
de editar estas duas animações para funcionarem corretamente dentro de nosso 
esquema. Para isso vá até a pasta de animações e duplique a animação de Pulo. 
 
Clique 2 vezes para editar a do início. 
Pause a animação para trabalhar melhor. Posicione a barra vermelha manualmente 
um pouco antes do personagem tirar os pés do chão, pouquíssimos frames antes. 
 
Clique com o botão direito sobre a posição escolhida e apague os frames iniciais. 
 
 
Mova manualmente a barrinha vermelha até um pouco depois que os pés saem do 
chão, e apague os frames depois da marcação atual. 
 
Salve e pronto temos o início do nosso pulo. Vamos abrir agora a próxima animação, 
Pulo Final. 
Dessa vez mova os frames até antes dos pés retornarem ao chão, e apague os 
anteriores. 
 
 
Depois que ele encostar no chão e dobrar um pouquinho os joelhos apague os frames 
seguintes. 
 
Salve. Caso a animação de queda precise de edição faça também. 
 
 
 
 
 
 
 
 
 
Configurando Animação de Pulo 
Vamos agora voltar ao Animation Blueprint. 
 
Arraste as 3 animações para ficarem nesse esquema mostrado. Agora vamos fazer 
as ligações entre esses estados, começando do Bland Space 1D para Pulo_inicio e 
terminando de Pulo_Final a Bland Space 1D. 
 
Note que agora nossas ligações possuem um círculo branco no meio, é ai que 
definiremos a condição de transição do pulo, e parte do processo de interação com 
os controladores. 
Clique 2 vezes no círculo entre a Bland Space 1D e Pulo_inicio. 
 
 
Devemos aqui criar uma variável Bolean que indique se o pulo é verdadeiro ou falso. 
 
Repita os seguintes esquemas respectivamente para os próximos nós. 
, 
 
 
Antes de irmos para o próximo passo certifique-se de que todas as animações não 
estão em Loop. Clique duas vezes em cada um dos nós das animações da sequência 
de pulo e desmarque Loop Animator. Repita isso nas 3 animações de pulo. 
 
 
 
 
 
 
 
 
 
 
 
 
Conclusão 
Agora vamos ao EventGraph e fazemos o seguinte esquema para acessarmos a 
animação de pulo corretamente ao apertar a Barra de Espaço no game. 
 
Vamos ao teste. 
 
 
Perfeito! 
 E assim concluímos nossas configurações básicas para um Player de um projeto 
SideScroller. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adicionando Animações 
Animation Blueprint e Animation Montage 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Adicionando Animações no State Machine 
Neste capítulo iremos adicionar animações ao nossos game characters, deixando as 
interações mais dinâmicas e arrojadas. Iremos adicionar direto no State Machine, e 
também aprenderemos a usar o Animation Montage. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Template do Projeto 
Para este projeto precisaremos de um Player já configurado com as animações 
básicas, como mostrado nos capítulos anteriores, e além dessas outras animações 
como combate e movimentação diferente, para adicionarmos ao projeto. 
 
 
Importe as novas animações que adicionaremos ao nosso Player Character, no 
exemplo iremos adicionar outra animação de correr, e 3 de combate. 
Vamos agora criar um BlendSpace 1D de nosso novo estado de movimentação. (para 
informações sobre como criar uma BlendSpace 1D vá a página 38) 
As animações deste exemplo farão o personagem parecer estar segurando uma 
tocha, porém você pode usar animações que façam o personagem parecer ferido ou 
andando sobre um lago, ou coisa parecida. 
 
Coloque no frame 0 o Idle deste novo estado, e no frame correspondente ao 
MaxWalk Speed, aqui é 50, a animação de correspondente ao novo estado correndo. 
 
 
Anim Graph do Animation Blueprint do player, e entre no State Machine. 
 
Ao abrirmos neste exemplo temos apenas o nó advindo do BlandSpace 1D com as 
animações bases do player. Iremos adicionar o novo BlendSpace 1D arrastando-o 
para o Anim Graph. 
 
 
Arraste e solte o novo BlendSpace no Anim Graph. Apartir do primeiro nó 
Blendspace, puxe uma ligação até o novo nó, retorne a partir desse último ao 
primeiro com outra ligação logo em seguida, como mostra a figura abaixo. 
 
Acessando o novo nó, adicione a variável correspondente a “Velocidade” do player 
ao nó interno do BlendSpace. 
 
 
Agora devemos clicar 2 vezes nos símbolos redondos que aparecerão entre as 
ligações para ter acesso a condição. 
 
 
Crie uma variável boleana para a condição de nosso novo estado. 
 
Na condição de ida colocamos a variável direta com o nó nativo Result. Já na 
condição de volta ao estado anterior, devemos colocar um NOT boleano, entre esses. 
 
 
Devemos agora criar uma comunicação entre essa condição e o player. Abra então o 
Event Graph do player character e lá crie uma variável boleana, aqui foi criada 
Tochamodo. 
 
Feito isso, abra novamente o Animation Blueprint do player e na aba EventGraph, 
traga o nó Cast To... aparecerão algumas opções, escolha a que segue com o nome do 
Player Blueprint, no caso do exemplo aqui foi Cast To Third Person Character. Não 
esqueça de conectar Get Player Character a Object em Cast To. 
 
Arraste uma ligação de As (o nome do seu character) e busque a variável que 
acabamos de criar, escolha Get como mostra a figura a cima. Essa variável será a 
condição da variável ModoTocha que criamos aqui no Animation Blueprint. 
 
 
Pronto! Acabamos de determinar que sempre que a variável Tochamodo no Player 
for verdadeira, a variável ModoTocha no Animation Blueprint também será, e 
quando isso ocorre o StateMachine trocará de Blendspace do personagem andando 
de “Normal” para “ComTocha”. 
Essa troca de estados pode ocorrer de várias formas diferentes, podemos definir no 
Event Graph do Player que ao apertar a tecla “F” Tocha modo será verdadeira. 
 
 
 
Ou podemos colocar Trigger Volume no level e ativarmos em Open Level Blueprint, 
a animação de correr com a tocha, somente ao passar nesse Triggler. 
 
 
 
 
 
 
 
 
Adicionando Animações Com Animation Motage 
Vamos adicionar agora ao mesmo projeto algumas animações de combate com o 
auxílio do Animation Montage. 
Primeiro, Importe as animações de combate. Clique com botão direito sobre cada 
uma e siga a imagem abaixo para criar o Animation Montage. 
 
Para organizar melhor nossas animações, coloque todas as criadas em uma pasta 
denominada Animation Montage. 
 
 
Temos aqui 3 animações de combate. Agora abra o Animation Blueprint do Player. 
Adicione um Defaut Slot entre o StateMachine e o Final Animation Pose. 
 
 
 
Clique agora na Lupa, na aba Sethings para nomearmos nosso Slote. 
 
No painel “Anim Slot Manager” clique na pasta com o texto Add Slot, e nomeie de 
acordo com o tipo de animação que você deseja chamar, no caso do exemplo está 
nomeada como Combate. 
 
Agora volte ao Anim Graph e em Slot Name mude o nome do slot para o nome que 
acabou de criar. 
 
 
 
Definimos com isso um Slot dentro de Animation BLueprint que “Puchará” filtrará 
as montagens de animações, desde que elas estejam configuradas adequadamente 
para pertencerem a este Slot, é o que faremos no próximo passo. 
Abra o Editor de cada Animation Montage criada e mude DefautGrup como mostra 
a figura abaixo: 
 
 
 
 
 
Você deve fazer issoem todos os Animations Montage que queira “puxar” do nó 
combate. 
Agora no Event Graph do Player Blueprint, chame o Nó Play Anim Montage, e atribua 
um botão para ativá-lo. 
 
Na opção Anim Montage, escolha uma das animações da lista. Tem de ser uma das 
que você acabou de configurar. 
 
 
Após compilar podemos conferir que ao Apertamos o botão correspondente ao 
evento, o personagem desferirá o golpe. 
 
 
Vamos deixar sua luta mais dinâmica agora. Conforme a imagem abaixo arraste uma 
ligação de Anim Montage e solte em um local vazio, escolha a opção “Promote to a 
Variable”. 
 
Criamos assim uma variável capas de carregar nela uma das montagens de 
animação. 
 
 
Para darmos vários golpes apertando o mesmo botão devemos atribuir entre o 
evento e a função um nó chamado Switch on Int. 
 
Esse nó permite criarmos nele múltiplos Pins de saídas (output) clicando em Add 
Pin. Como temos 3 animações de golpe vamos adicionar mais 2 Pins. 
 
 
Vamos agora arrastar nossa variável “Anim Mont” e escolher Set, depois criar 2 
cópias da mesma. 
 
Como fizemos com Play Anim Montage, vamos adicionar as animações de combate 
direto nas variáveis. 
Atrinua agora a função Randim Integer in Rage ao nó Switch para que possamos 
carregar as animações com um clique de forma randômica. 
 
 
Atenção a configuração da função Random Integer, onde Min e Max setam a 
quantidade de Pins que possuem o Switch a ele ligado. 
Vamos testar nosso código? 
 
Pronto! Agora podemos transitar entre as 3 animações de luta de forma randômica 
com o mesmo comando. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Inteligência Artificial I 
Perseguição 
 
 
Inteligência Artificial I 
Projeto Perseguição 
Neste capitulo estaremos aprendendo conceitos básicos sobre inteligência artificial 
dentro da ferramenta Unreal Engine 4, aprenderemos desde tópicos até a 
implementação de um sistema de perseguição. 
 
Template do projeto 
Precisaremos de um template para iniciarmos nossos estudos. Optei por utilizarmos 
template em terceira pessoa, pois não precisaremos nos preocupar com a 
implementações básica de controle do jogador que já fora visto, bem como a 
construção de um mapa para possíveis testes. 
Lista de Passos: 
• Executar o Laucher 
• Criar um projeto em Blueprint 
• Definir as configurações iniciais 
Primeiramente execute o Launcher da Epic Games e em seguida clique em 
Inicializar. 
 
Em seguida surgira uma nova janela. Nela iremos definir as configurações básicas 
do nosso projeto. 
Escolheremos Novo projeto e escolheremos faze-lo em Blueprint, definiremos que 
o template a ser usado será o de terceira pessoa e então escolheremos o local onde 
será salvo e seu respectivo nome. 
 
 
 
Configurando a IA 
Com o projeto já criado podemos então começar a desenvolver nosso inimigo. 
Deveremos criar um Character que seja nosso inimigo e então atribuir a ele um 
AIController que irá controlar nosso inimigo, em seguida precisaremos definir uma 
área de atuação e então colocar o nosso inimigo na cena para que comece a seguir 
nosso jogador. 
 
Como já vimos, quando criamos um Character, que nada mais é que um Pawn com 
algumas funcionalidades características de player, estamos definindo um 
personagem, porém não é nele que definimos como iremos controla-lo e sim em seu 
PlayerController. 
O mesmo ocorre com a inteligência artificial, precisaremos de um AIController que 
irá definir como nosso inimigo será controlado, será nele que iremos programar as 
decisões e ações a serem tomadas. 
 
• Criar um novo Character “CH_IA1” 
• Fazer Configurações básicas 
• Criar um novo AIController “AIC_AI1” 
• Atribuir AIC_AI1 para CH_IA1 
Agora criaremos uma nova pasta dentro de Content chamada IA1 e nela iremos criar 
um novo Blueprint do tipo Character e definiremos seu nome como CH_IA1, este 
será o nosso inimigo. 
 
 
Abra o Blueprint que acabamos de criar selecione o componente Mesh na aba 
“Components” e defina qual o Skeletal Mesh que será usado, neste caso irei usar o 
padrão. 
 
Defina o “Anim Class” como ThirdPerson_AnimBP, e posicione seu personagem 
como na imagem. 
 
 
Até o momento definimos nosso personagem, mas ainda não definimos quem irá 
controla-lo, como este será um inimigo, não será controlado pelo jogador e então 
não poderemos usar o PlayerController, neste caso iremos definir que ele será 
controlado por uma inteligência artificial, ou seja, iremos criar um AIController e 
atribuiremos ao personagem este controlador. 
Crie um novo Blueprint, mas agora pesquise em All Classes o tipo AIController e 
defina seu nome para AIC_IA1. 
 
Ficaremos então com a seguinte configuração de arquivos. 
 
 
O próximo passo é definir o controlador do nosso CH_IA1 para AIC_IA1. Para isso 
devemos abrir o CH_IA1 selecionar em Components o componente self e então na 
aba details altera o valor de AI Controller Class para IAC_IA1. 
 
Pronto com isso nossa configuração da inteligência artificial está pronta, pois 
criamos um personagem e definimos que ele será controlado pelo controlador de 
inteligência artificial que criamos. 
Programando a IA 
Agora que temos nosso inimigo configurado vamos programar a IA, ou seja, como 
ele irá atuar sobre o local onde está, em nosso caso iremos fazer com que o inimigo 
sempre encontre o player e comece a segui-lo para sempre. 
Como este é um comportamento de controle sobre o inimigo, vamos ter que definir 
a programação no AIController que criamos, abra então o IAC_IA1. 
Na aba Event Grath iremos realizar uma pesquisa procurando o Character do 
jogador, e em seguida iremos nos mover até ele. 
 
 
 
Questão: 
Em algumas situações especificas este código pode gerar um erro. Você sabe qual é? 
Questione com seus colegas como resolve-lo. 
 
Área de atuação “Nav Mesh” 
Nosso inimigo está configurado e sua inteligência definida. Podemos arrasta-lo para 
a cena e dar play, porém ele nada irá fazer pois ele não sabe que ele está em um 
mundo e muito menos sabe que pode andar nele. Para que ele saiba de tudo isso e 
possa encontrar nosso player devemos informa-lo que está em um mundo e fazemos 
isso com o Nav Mesh. 
O Nav Mesh é uma malha de navegação que irá definir por onde nossa a IA irá se 
mover, delimitando assim seu percurso e evitando obstáculos que entejam entre o 
inimigo e o seu objetivo. Quando uma Nav Mesh está em cena ela irá pintar as 
possíveis áreas de locomoção para que no futuro uma IA saiba por onde andar. 
Vamos então criar uma Nav Mesh. Na aba principal do projeto vá para a sub aba 
Modes em Place pesquise Nav Mesh. Arraste ela para a cena como na imagem. A 
área verde em destaque é onde a IA pode andar. 
 
 
Por padrão a área verde não fica amostra. Devemos habilitá-la clicando em Show na 
própria View Port e então clicar em Navigation como na imagem abaixo. 
 
Sabendo que a área verde é onde a IA poderá se locomover, podemos perceber que 
ela nunca irá encontrar ou chegar até nosso player, devemos então redimensionar o 
Nav Mesh para que ocupe toda a nossa cena como na imagem abaixo. 
Pronto! Podemos agora executar o jogo e ver nosso inimigo perseguindo o player 
para onde quer que ela vá. 
 
 
Conclusão 
Trabalhamos apenas com Blueprints, porém, existem ferramentas especificas para 
a programação de IA como BalckBoards, BehaviorTree, mas falaremos disso mais 
adiante. 
Aguçando a curiosidade 
Conseguimos então criar um inimigo com uma inteligência artificial bem simples, 
ele inicia encontrando o player e começa a segui-lo. Seria mais interessanteque ele 
começasse a segui-lo apenas se chegássemos muito próximo dele, como faríamos 
isso? 
Podemos ver ainda que existe uma área verde nas escadas levando até um nível mais 
alto, mas se não existisse essa escada ele não subiria, você consegue corrigir isso? 
Na próxima apostila falaremos sobre esses problemas e suas soluções. Até lá. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Inteligência Artificial II 
 
 
 
 
 
Inteligência Artificial II 
Projeto Perseguição II 
Nesta apostila estaremos aprendendo mais sobre inteligência artificial dentro da 
ferramenta Unreal Engine 4, iremos construir um sistema de chave & porta para 
passarmos de nível bem como checkpoints, iremos ainda nos aprofundar na criação 
de um sistema inteligente. 
O Curso consiste em três apostilas sendo que está conterá os tópicos medianos sobre 
inteligência artificial em jogos digitais. Continuaremos trabalhando com Blueprints 
çã 
 
para que na Inteligência artificial III você consiga perceber o porquê de utilizar o 
sistema de IA da Unreal engine 4 ao invés de Blueprint puro; 
 
 
Template do projeto 
Precisaremos de um template para iniciarmos nossos estudos. Optei por 
utilizarmos template em Side Scroller, pois não precisaremos nos preocupar com a 
implementação básica de controle do jogador que já fora visto, bem como a 
construção de um mapa para possíveis testes. 
Lista de Passos: 
● Executar o Laucher 
● Criar um projeto em Blueprint 
● Definir as configurações iniciais 
Primeiramente execute o Launcher da Epic Games e em seguida clique em 
Inicializar. 
 
Em seguida surgirá uma nova janela. Nela iremos definir as configurações básicas 
do nosso projeto. 
Escolhemos Novo projeto e escolhemos fazê-lo em Blueprint, definiremos que o 
template a ser usado será o de Side Scroller e então escolhemos o local onde será 
salvo e seu respectivo nome, incorpore o StarterContent ao projeto. 
 
 
Organizando os diretórios 
Com o projeto já criado podemos então começar organizando nosso diretório, 
devemos criar uma pasta chamada AI2 na raiz do Content logo em seguida mova o 
mapa padrão do projeto para esta pasta. Faça o mesmo para SideScrollerCharacter 
e retomei-o para Jogador. 
 
Vamos alterar as configurações de mapa, pois como mudamos de local quando 
abrirmos a Unreal Engine novamente ela não irá carregar automaticamente o mapa 
atual. Para isso vá em Edit ->Project Setting -> Maps & Mode de defina o mapa atual 
como padrão. 
 
 
Vamos iniciar o desenvolver nosso cenário para que possamos testar toda a nossa 
programação como sistema Chave&Porta, inteligência artificial, elevadores entre 
outros. 
Na imagem abaixo podemos ver como ficou o layout do mapa, utilizando e 
duplicando apenas os próprios blocos que já estão na cena, recomendamos que não 
crie um layout novo, mas sim replique este para que não haja obstáculos 
inesperados em nosso aprendizado, depois podem ficar à vontade em criar os seus... 
aliás fica atividade extra trazer mapas diferentes com o que aprender nesta apostila. 
 
 
 
 
 
Sistema Chave&Porta / Pontuação I 
Neste sistema o jogador deverá achar e coletar uma chave para uma determinada 
porta, o mecanismo poderia ser usado para outros fins como pegar uma armadura 
aprova de fogo para então poder lutar contra um dragão. 
Podemos perceber que tanto as moedas como as chaves serão coletadas certo? 
Temos então duas opções: 
● Opção 1 o Criar uma Blueprint Actor para cada uma delas e programar se o 
player as tocou e então executar a soma de pontos ou guardar a chave 
consigo. 
● Opção 2 o Criar uma classe Actor base que determine se o player tocou 
aquele objeto, e criar mais duas classes que implementam apenas as 
respectivas ações. 
 
Se formos analisar na opção 2 temos 3 arquivos enquanto na opção 1 teremos 
apenas 2, você pode pensar “Para que criar 3 arquivos se 2 já dão conta do recado? 
” 
Realmente para este exemplo não parece que seria vantajoso, mas se formos 
analisar todo o projeto dessa apostila veremos que existe coisas em comuns entre 
Chave, Porta, Checkpoint, Moedas, Zona de morte, Trigger ... 
Para cada um deles teremos de inserir um BoxCollider e detectar o evento de 
BeginOverlap e EndOverlap que são os eventos que determinam se alguma coisa 
tocou neles ou se deixou de tocar, logo para não termos de reconfigurar todo o 
Blueprint toda vez que criarmos algo, basta utilizar este objeto base, a isso 
chamamos de Herança. 
Vamos então pela opção 2 para treinarmos esse novo conceito já que a opção 1, 
vocês já sabem como fazer. 
Crie um Actor chamado A_ObjetoBase, adicione uma “Box Collision” chame-o de 
Detector e defina como root da cena, este servira para nos avisar se alguém tocou 
neste objeto. 
 
 
Vamos então realizar algumas tarefas, 
1. Acione o BeginOverlap do Detector. 
2. Na aba EventGraph crie um CustomEvent chamado “Jogador Detectado” 
com uma variável de entrada chamada Jogador, este evento será chamado 
quando um player for detectado. 
3. Cri outro CustomEvent da mesma forma e renomeei para “Jogador Perdido” 
4. Na sequência do BeginOverlap na aba EventGraph faça um Cast do variável 
jogador confirmando se realmente é um jogador, caso seja execute o evento 
Jogador Detectado. 
5. Na sequência do EndOverlap na aba EventGraph faça um Cast do variável 
jogador confirmando se realmente é um jogador, caso seja execute o evento 
Jogador Perdido. 
 
 
 
 
 
 
 
 
 
Tudo deverá ficar como na imagem abaixo. 
 
 
 
Agora poderemos criar nossos Blueprints que herdaram este objeto, o que 
precisaremos fazer depois é apenas especificar o que vai ser executado quando 
Jogador Detectado e jogador Perdido forem executados, resumindo não 
precisaremos criar tudo de novo a cada novo ator da cena. 
 Agora crie um ator que irá herdar a classe A_ObjetoBase e chame-o de A_Chave da 
seguinte forma: 
 
No EventGraph deste arquivo crie um novo CustomEvent e coloque o mesmo nome 
e entradas que definimos para o A_ObjetoBase Faça isso para o “Jogador Detectado” 
 
e defina uma nova ação que será executada apenas para a chave, isso irá substituir 
a ação da classe pai. 
Veja como ficou para a Chave: 
 
Perceba quecomo utilizamos Herança, nosso ator A_Chave já tem um Box Collider 
bem como os eventos de detecção, o que precisamos fazer é Recriar o CustomEvent 
com o mesmo nome e parametros, para que este ator tenha uma execuao diferente 
dos outros. 
 
Repita esses passos criando agora o ator A_Moeda: 
 
Antes de colocarmos a chave e moeda em cena para testar vamos adicionar seus 
respectivos ícones. 
Cri uma pasta chamada Ícones dentro de IA2 e importe as imagens do curso, escolha 
a imagem Icone_Chave clique sobre ela com o botão direito do mouse em Create 
Sprite. Faça o mesmo processo para as outras imagens ao final teremos esta 
configuração. 
 
 
Volte para o A_ObjetoBase e adicione o componente Arrow e faça com que ele seja 
o root da hierarquia veja que esse mesmo componente apareceu para a chave e a 
moeda. 
Volte para a A_Chave e adicione um novo componente chamado PaperSprite 
informe o Sprite correspondente e remova a colisão. Faça o mesmo para a moeda. 
 
Criando a porta 
Vamos agora criar a porta para nossa chave, para isso crie um novo Actor com o 
nome A_Porta herdando de A_ObjetoBase e siga os passos: 
Adicione uma StaticMesh para o actor, defina o mesh SM_Door para este 
componente reposicione e escale o Detector para quando o Jogador chegar aquele 
local a porta verifique se ele tem a chave certa. 
 
 
 
 
Sobre escrevao CustomEvent Jogador Detectado criando este evento na aba 
EventGraph da mesma forma que fizemos com a chave e moeda. 
 
Crie uma variável pública com o nome MinhaChave do tipo A_Chave, esta será a 
chave da porta e no fim tudo deverá ficar da seguinte forma. 
 
 
 
Agora posicone varias moedas na cena, uma porta e uma chave, estamoa usando 
apenas uma chave mas voce podera usar quantas portas e chaves desejar. 
 
Posicione uma chave na cena bem como várias moedas espalhadas: 
 
O elevador 
Vendo a imagem acima chegamos a um ponto no cenário que não conseguimos 
chegar ao patamar de cima, para conseguirmos vamos construir um elevador, vamos 
aos passos então. 
1. Crie um novo ator e de o nome de A_Elevador herdando A_ObjetoBase 
2. Adicione um StaticMesh, e defina a mesh como 1M_Cube 
3. Reposicione e redimensione o Detector 
4. Realize a sobre escrita do CustomEvent Jogador Detectado 
 
 
 
 
Controle de estados 
Quando nosso player morrer devemos diferenciar se ele morreu na queda ou se 
morreu pelo inimigo, mas como faríamos isso? 
Poderíamos usar uma variável do tipo integer e dizer que caso o valor seja 0 significa 
que o player morre pelo inimigo, e caso seja 1 ele morreu pela queda, porém essa 
solução não é interessante pois pode gerar dúvidas e muitos problemas conforme o 
projeto comece a ficar maior, imagine 100 estados diferentes sendo definido dessa 
forma entre diversas classes! 
Para isso temos o Enum, nele podemos organizar nossos estados de forma mais 
clara e organizada. 
 
Com o Enum criado defina seu nome para E_Estados e abra este arquivo criando 
três estados. 
● Vivo o Estado em que o player ainda está vivo 
● MortoPeloInimigo o Estado informa que o player 
morre pelo inimigo 
● MortoPorAreaPerigosa o Estado informa que o player 
morreu por entrar em uma área de perigo, podemos 
pensar como sendo Lava, área radioativa ... 
 
 
 
Programação no Player (Jogador) 
Até o momento construímos a cena e os itens que usaremos no jogo, mas nada de 
programação... bem isso acaba por aqui vamos programar! 
Vamos iniciar a programação criando o inventario do Jogador, onde guardaremos 
todas as chaves e o número de moedas que pegamos durante a fase. 
Crie uma variável do tipo A_Chave chamada Chaves e marque-a como lista de 
A_Chave clicando no quadriculado ao lado do tipo de variável. 
Crie também uma variável do tipo integer chamada Moedas, a usaremos para contar 
quantas moedas pegamos na cena. 
Precisaremos ainda do estado do player então crie uma variável do tipo E_Estados e 
chame de EstadoAtual. 
E por fim teremos um sistema de Checkpoint logo devemos guardar a posição em 
que ele se encontra para isso vamos criar uma variável do tipo Vector e chamada 
de CheckPointEncontrado. 
 
 
 
Sistema Chave Porta / Pontuação II 
Vamos voltar nossa atenção agora para o cenário, nele deixamos já configurado uma 
porta e uma chave, assim como várias moedas e o elevador pelo uso de herança agora 
só precisamos definir para cada ator o que seu evento Jogador Detectado deve fazer. 
 
 
Abra o arquivo A_Moeda encontre o CustomEvent Jogador Detectado que criamos e 
altere sua lógica. 
Pegue a variável moedas do nosso jogador e realize o incremento e imprima o novo 
valor na tela depois destrua o objeto. 
 
 
Chaves 
Abra o arquivo A_Chave encontre o CustomEvent Jogador Detectado que criamos e 
altere sua lógica. 
Pegue a variável Chaves que é uma lista e adicione a própria moeda a essa lista 
depois mova ela para fora da vista do jogador. 
 
Portas 
Abra o arquivo A_Porta encontre o BeginOverlap que criamos e altere sua lógica. 
No evento Jogador detectado procure MinhaChave dentro da variável Chaves do 
caso exista iremos abria a porta. 
Adicione uma TimeLine que irá variar de 0 a 90 o nome da variável de saída será 
AnguloAtual, ela deve ter 2 segundos de duração, clique com o shift pressionadora 
criar dois pontos, clique no primeiro ponto de defina o tempo e valor para zero, 
clique no segundo ponto e defina seu tempo para 2 e seu valor para 90. 
 
 
 
 
Defina a rotação da porta para ser igual ao valor de saída da TimeLine um Doonce 
para que seja feita apenas uma vez a ação tudo deverá ficar como na imagem. 
 
 
Temos ainda que definir qual chave pertence a nossa porta, para que ela seja aberta 
caso o jogador tenha a chave. 
Selecione a porta que está na cena, vá para o painel de detalhes e no campo default 
você verá a variável MinhaChave, clique no conta gotas e depois clique na chave que 
está na cena assim a chave será atribuída àquele objeto. 
 
 
Elevador 
Ainda não conseguimos chegar até a porta pois o player na pula tão alto, por isso 
criamos o elevador e iremos programa-lo agora. 
Para o evento Jogador Detectado crie uma nova Timeline chamada Subir, que terá 
duração de dois segundos, crie uma variável com nome Altitude e dois pontos, o 
primeiro em time e valor igual a zero e o segundo time igual a 2 e valor igual a 7, 
para mim esses valores foram suficientes para que o elevador subisse até o topo 
adapte para o seu projeto. 
 
 
Agora para o elevador descer use o evento Jogador Perdido, duplique a TimeLine e 
multiplique a altitude por menos um, assim o elevador começara a descer logo que 
o player sair dele. 
 
 
Checkpoint 
Vamos brincar com o Checkpoint, para isso vamos usar a mesma lógica que usamos 
para a chave, você se lembra como fizemos? 
Crie um novo ator que herde de A_ObjetoBase, defina o ícone 
Icone_CheckPoint_Sprite que criamos a partir do Icone_CheckPoint como fizemos 
coma moeda e chave lembre-se de remover a colisão do ícone, realize a sobre escrita 
do evento Jogador Detectado, quando este evento ocorrer pegue a posição do 
checkpoint e defina para a variável CheckPointEncontrado do jogador. 
 
Além disso devemos definir a posição inicial do jogador para a variável 
CheckPointEncontrado pois caso ele morra sem encontrar um checkpoint esse 
será colocado na posição (0,0,0), para isso vamos para o Jogador e no evento 
Beginplayer definimos o valor da variável como sendo a posição que o player 
iniciou. 
 
 
 
Posicione alguns checkpoints pela cena. 
Zona da morte 
Para usarmos o nosso sistema de checkpoint temos que morrer primeiro né? Então 
crie um novo ator chamado A_AreaPerigosa herdando de A_ObjetoBase assim 
como no checkpoint adicione um PaperSprite e coloque o ícone 
Icone_lancas_Sprite remova a colisão do Sprite. 
 
E vamos repetir o mesmo processo do checkpoint porem agora iremos trocar o 
estado do player para MortoPorAreaPerigosa e após um delay de 2 segundos 
vamos chamar o CustomEvent Jogador Morreu que criaremos no Jogador logo 
abaixo. 
 
 
No Blueprint do Jogador crie este CustomEvent que chamamos a variável de entrada 
é do tipo E_Estados, troque o estado a atual para o estado que foi passado no 
parâmetro e depois de 2 segundos reposicione o player para a posição do checkpoint 
e traga o de volta a vida. 
 
Assim já mudamos o estado do jogador para morto e podemos trocar a animação 
dele por uma animação de morte. 
Adicione este ator a cena para que o player possa começar a morrer, vejamos como 
ficou agora. 
 
 
O inimigo (IA) 
Todo o jogo já está funcionando, pegamos moedas, conseguimos abrir portas 
morrermos em áreas perigosas temos o nosso inventario. 
 
Vamos então começar a trabalhar nossa inteligência artificial, ela irá perseguir o 
nosso jogador e matá-lo caso o toque. 
Primeiramente vamos repetir o passo da apostila anterior inserindo na cena um 
“Nav Mesh Bounds Volume” na tab Modes. 
 
Redimensione o volume para que ocupe toda a área do