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 domapa. 
 
Você se lembra que onde fica verde, para ver o verde clique em Show e Navigation, 
é onde o inimigo poderá andar né? Então já percebeu que nos blocos que o jogador 
está não existe uma área verde né? Isso acontece, pois, o NavMesh precisa de uma 
certa largura para ser criado na mesh, e para resolver este problema só precisamos 
aumentar a largura dos blocos. 
 
 
O terreno para o inimigo está pronto, mas ainda não temos o inimigo, crie então um 
novo “BluePrint Character” e de o nome de CH_Inimigo e configure seu SkeletalMesh 
e sua AniamationBlueprint igual ao do Jogador. 
 
Crie outro Blueprint do tipo AIcontroller, você pode encontra-lo em All Classes no 
popup de novo Blueprint, chamado AIC_Inimigo este será a inteligência artificial do 
nosso inimigo. Defina-o como controlador padrão do CH_Inimigo. 
 
Neste controlador faça com que o inimigo logo que entrar em cena, guarde a posição 
dele em uma variável do tipo Vector chamada Posição inicial 
 
 
E a cada evento Tick ele veja se tem algum player na cena, caso tenha e esteja vivo 
persiga-o, caso não esteja vivo ele volta para a posição inicial dele. 
 
Mas ainda temos de fazer a mudança de estado do player quando ele for tocado pelo 
inimigo, para isso crie um SphereCollider no CH_Inimigo faça o Cast para o jogador 
e então mude o estado chamando a função Jogador Morreu e passando como 
parâmetro MortoPeloInimigo. 
 
 
Prontinho! Nosso inimigo já está fazendo tudo que tem de fazer porem se você 
começar a subir nos blocos e elevador e outros níveis diferentes do chão poderá 
 
perceber que ele não soube níveis algum, essa é uma questão que deixamos na 
apostila anterior e que agora iremos resolver. 
Subindo níveis! 
Nosso inimigo segue o player apenas no NavMesh verde que é gerado, quando existe 
uma descontinuidade desse NavMesh o inimigo não com segue ir até lá, na verdade 
ele nem sabe que pode existir uma NavMesh em outro lugar que não seja a dele. 
Para avisarmos a ele que existe outros lugares que ele pode andar, precisamos usar 
o “Nav Link Proxy”, ele existira dois PointLinks que iremos posicionar na cena 
informando de onde para onde o inimigo pode ir. 
 
Porem precisamos posicionar os PointLinks de forma que surja uma linha verde 
ligando os dois, abaixo terá as imagens mostrando a forma errada e a correta. 
 
Corrigindo a posição: 
 
 
 
 
Posicione outros desses nas áreas que precisam ser escaladas pelo inimigo da 
seguinte forma. 
 
De o play no game e veja que o inimigo agora sabe que naqueles pontos ele poderia 
ir para o andar de cima, mas não consegue ir pois os PointLinks apenas avisam locais 
para o inimigo. 
Vamos então criar um novo actor chamado A_Pular, mas dessa vez não iremos 
herdar de A_ObjetoBase, que irá avisar que ele deve fazer algo quando chegar ali 
deverá pular conseguindo assim subir no bloco, neste ponto você pode usar 
animações para fazer com que ele escale a parede, ou faze-lo teleransortar isso vai 
de sua decisão. 
 
 
 
 
Posicione então este novo ator próximo aos PointLinks para que quando a IA chegue 
naquele local ela pule. 
 
Com isso nosso inimigo consegue subir e descer nos níveis da fase, experimente 
fazer alguns destes testes e ajuste as suas necessidades. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Inteligência Artificial III 
Confronto I 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Inteligência Artificial III 
Projeto Confronto I 
Nesta apostila estaremos trabalhando com conceitos de confronto entre player e a 
IA, teremos de lidar com comunicação entre os inimigos ou entidades bem como o 
próprio player. 
O Curso consiste em três apostilas sendo que está conterá os tópicos medianos sobre 
inteligência artificial em jogos digitais. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Template do Projeto 
Precisaremos de um template para iniciarmos nossos estudos. Optei por 
utilizarmos template em Third person, 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 Third person e então escolhemos o local onde será 
salvo e seu respectivo nome. 
 
Configuração inicial do projeto 
Em seguida cria uma pasta Chamada IA3 e mova para dentro dela os Character e 
Mapa padrão do projeto. 
 
 
Vamos criar agora nossa ia, a ideia aqui é replicar de forma simples uma ia no estilo 
circular, similar ao sistema de ao usado em Assassin’s Creed e Batman: Arkham. 
 
Ainda usaremos o sistema de blueprint para vermos como pensar, pois, muitas das 
implementações ficam implícitas quando usamos os sistemas de Behavior Tree 
Blackboard. 
 
Crie então o Character para a IA e IAController nomeando-os para CH_IA3 e IAC_IA3, 
informe a Mesh, Animation Blueprint bem como o IAController para o CH_IA3. 
 
Vamos então definir o navmesh e em seguida posicionar quatro de nossos inimigos 
em cena. 
 
Abra o ThirdPersonCharacter e altere o CameraBoom setando o valor de “Do 
Collision Test” para false, para que assim a câmera não aproxime do player caso 
 
algo fique entre ela e o player. Caso queira afastar a câmera um pouco para que 
tenhamos uma visualização mais abrangente. 
. 
 
Game design 
Como a inteligência artificial do inimigo será semelhante ao Batman: Arkham nosso 
inimigo tentará que obedecer alguns protocolos ou regras para que o gameplay se 
desenrole, isso é definido no design da inteligência artificial. 
Neste jogo o player não irá poder atacar os inimigos, irá apenas andar e se defender 
seguindo a sabedoria dos antigos mestres de kung fu. 
Vamos então criar o IA Design: 
• O inimigo terá os seguintes estados o Patrol 
▪ Estado em que ainda não encontrou o 
jogador o Following 
▪ Se posicionando o OnGuard 
▪ Esperando para poder atacar o 
Fighting 
▪ Está lutando com o jogador 
 
• O inimigo quando avistar o player ira se posicionar para ataque e ira persegui 
lo 
• Quando perto do player ele devera circundar o jogador 
• O ataque será realizado em turnos, ou seja, quando um inimigo estiver 
atacando todos os outros não estarão. 
• O turno só acaba quando o player acaba de receber um ataque ou quando ele 
acabar de bloquear. 
• A escolha de quem irá atacar é randômica. 
Imagine-se sendo o inimigo que vamos programar, quais seriam suas primeiras 
ações com relação ao que foi descrito acima? Você sabe que tem de ir aí o player, 
 
mas onde até o player ou quando? Pense nisso e liste o passo a passo, quando mais 
detalhado melhor. 
Abaixo uma possível lista de ações: 
1. Qual estado eu início? 
2. Existe algum player próximo a mim? 
3. Onde está o player onde irei me posicionar? 
4. A que distância do player devo ficar em guarda? Ou sair da guarda? 
5. Como irei me afastar do player caso ele se aproxime de mim? 
6. Quando que eu posso atacar? 
 
 
Agora que já definimos como o inimigo irá agir podemos iniciar a programação 
respondendo as questões da lista acima. 
 
Qual estado eu início 
Como no mundo real ninguém fica lutando sozinho, o mais lógico seria esperar uminimigo surgir para então nós preparamos e depois ver se precisamos lutar. Então 
vamos fazer com que a nossa uma se inicie em Patrol. 
Crie um enum chamado E_IAState e defina os estados listados no ia design: Patrol, 
Following,OnGuard, Fighting. 
 
Logo em seguida crie uma variável no IAC_IA3 chamada state do tipo E_IAState e 
defina seu valor default para Patrol. 
 
 
 
 
 
 
 
Resumo de funções e variáveis 
Como ira existir muita comunicação entre os blueprints, achamos que seria melhor 
listar aqui todas as funções e variáveis que devem ser criadas, mas a frente 
explicaremos cada uma delas. 
1. ThirdPersonCh
aracter o 
Variáveis 
Globais 
▪ MaxAround 
 Variável do tipo integer responsável por definir quantos 
inimigos podem ficar a uma certa distância. 
▪ CountAround 
 Variável do tipo integer responsável por informar 
quantos inimigos estão me cercando. 
▪ MinRadius 
 Variável do tipo integer responsável por determinar a 
distância mínima que os inimigos devem ficar do 
player. 
▪ PrepareForDefence 
 Variável do tipo boolean responsável por informar que o 
jogador está sendo atacado. 
▪ InFight 
 Variável do tipo boolean responsável por informar que o 
player e o inimigo estão lutando. 
▪ InDamage 
 
 Variável do tipo boolean responsável por informar que o 
player está sofrendo um dano do inimigo por não ter 
contra-atacado atempo. 
o Funções 
▪ GetPoint 
• Retorna um ponto ao redor do player 
▪ GetRaioAngle 
• Responsável por determinar a distância e a posição em 
que o inimigo ira se posicionar. 
▪ GetOffset 
• Pega o offset da posição retornada pelo GetRaioAngle. 
▪ AlertPrepareForDefence 
• Realiza a sinalização visual e lógica de que o player está 
para ser atacado. 
2. IAC_IA3 o 
Variáveis 
▪ state 
 Variável do tipo enum E_IAState, indicará em que estado 
nosso inimigo se encontra. 
▪ BestOffSetPoint 
• Variável do tipo vector2d que irá guardar o offset para 
somarmos a posição atual do player e sempre termos um 
posicionamento certo. ▪ AreaOfAttack 
• Variável do tipo booleana que informará se o inimigo está 
próximo o suficiente para atacar. 
o Funções 
▪ ToFollowing 
• Altera o estado para perseguição 
▪ ToOnGuard 
• Altera o estado para modo de batalha 
▪ GetPointToMove 
• Retorna um vector3d baseado na posição atual do 
player e no offset. 
▪ LookToPlayer 
• Faz com que o inimigo olhe para o player 
▪ PositionInCircle 
• Determina uma posição ao redor do player 
3. CH_IA3 o 
Funções 
▪ ToOnGuard 
▪ ToFollowing 
▪ EnterAreaOfAttack 
▪ 
 
Existe algum player próximo de mim? 
Para respondermos essa pergunta podemos criar uma Sphere Collision de raio 400 
no ThirdPersonCharacter e ative o evento BeginOverlap e EndOverlap para verificar 
se o um inimigo no caso CH_IA3 está próximo. 
Coloque também um outra Sphere Collision de raio 250, esta iremos usar mais tarde. 
 
 
Quando o evento for acionado faremos o cast para CH_IA3 verificando assim se 
realmente é um inimigo logo em seguida iremos chamar a função “ToOnGuard” e 
“ToFollowing”, que já deve ser criada no CH_IA3 e chamada respectivamente em 
BeginOverlap e EndOverlap do player para o trigger. 
 
 
 
Crie as mesmas funções também no IAC_IA3. 
 
 
 
Para a função ToOnGuard vamos pegar a referência do IAController e chamar a 
função ToOnGuard do controlador. 
 
Agora vamos começar a controlar o estado do nosso inimigo por meio de enum. Crie 
um novo enum chamado E_IAState e no IAC_IA3 crie uma variável deste tipo 
E_IAState chamada state. 
 
Ainda no IAC_IA3 vamos chamar o evento Tick e executaremos um switch para a 
variável state assim conseguiremos controlar as ações dependendo de qual estado 
estivermos. 
 
 
Perceba agora que para cada estado podemos tomar um caminho diferente. 
Agora só falta alterar os estados do inimigo, fazemos isso pela funções 
“ToOnGuard” e “ToFollowing” que são chamadas quando o player detecta o 
inimigo e quando ele o perde de vista, quando detectado vamos fazer com que o 
inimigo se posicione em guarda. 
 
 
e quando sair da área do trigger ele ficará no estado de perseguição. 
 
 
Onde está o player onde irei me posicionar? 
Agora que sabemos que existe um player, o próximo passo é saber nos posicionar, 
vamos começar pelo estado Following. 
Para ele só precisaremos pegar a referência do player e chamar a função “Move to 
Actor” da seguinte forma. 
 
Agora vamos brincar com o Onguard, nele vamos fazer o inimigo olhar para o player, 
se posicionar e tentar atacá-lo. 
Crie uma função chamada “PositionInCircle” ela devera atualizar o 
BestOffSetPoint, vamos então realizar o cast do player e pedir para ele o offset, pois 
em nossa lógica deixaremos apenas 4 inimigos a um raio de 200 cm e os próximos 
4 inimigos com o dobro do raio e assim por diante. 
Teremos ainda de encontrar uma posição ao redor do player para que nosso inimigo 
começa a cercar o jogador, está matemática de posicionamento é a principal função 
deste game play, pois é nele de toda a inteligência estará, quando mais casos serem 
tratados melhor será nosso inimigo. 
 
 
Agora vamos para o ThirdPersonCharacter, pois é ele que saberá quantos inimigos 
estão te perseguindo. 
Crie a função “GetOffset” sela ira retornar um offset, mas para isso precisamos 
escolher uma posição ao redor do player certo? E ainda a cada 4 inimigos vamos 
dobrar a distância que ficaram do player. 
 
Aqui criaremos uma função chamada “GetRaioAngle” que será responsável por 
calcular a distância que os inimigos ficaram do player dependendo de quantos 
inimigos já estão perseguindo, e ainda o ângulo ao redor do player de 0 a 360 
estamos usando um valor integer para evitar valores como 12.7678. 
 
 
Nele dividimos o número de inimigos redor pelo número máximo permitido, em 
nosso caso será 4, mas você pode escolher outros valores, a distância mínima do 
inimigo ao player será de 200 cm. 
 
 
Com isso temos o ângulo ao redor do player e uma distância dele, mas ainda 
precisamos calcular com essas informações o ponto ao redor do player para então 
calcular o offset, para isso criamos a função “GetPoint” 
Primeiro calculamos um vetor direção normalizado pois este será nosso ponto 
angulo zero. 
 
Logo em seguida multiplicamos este vetor pela distância passada por parâmetro que 
encontramos no passo anterior encontrando assim um ponto com ângulo 0 redores 
do player, porém queremos um ponto com o ângulo do parâmetro então realizamos 
a rotação deste vetor com a função “Rotate Vector Around Axis”. 
 
 
Com isso voltamos para a função GetOffset com o ponto correto, calculamos offset 
pela diferença deste ponto com a posição do player e atualizamos a variável 
BestOffSetPoint da função PositionInCircle la do nosso IAC_IA3 … ufa sobrevivemos. 
Agora a parte fácil é só colocarmos isso para funcionar no estado de Onguard, mas 
antes vamos criar a fundação que irá fazer com que fiquemos olhando para o player 
quando estivermos em guarda, chamaremos ela de “LookToPlayer” . 
Nele teremos de pegar a posição de inimigo e do player para calcularmos a rotação 
utilizando a função “Find Look At Rotation” e vamos corrigir para que quando o 
player pular os inimigos não girem em torno de y pois ficaria bem estranho. 
 
Agora só precisamos calcular a posição que devemos seguir baseado no offset que 
adquirimos quando entramos em guarda e achar o ponto que temos de seguir ao 
redor do player, fazemos isso com a função GetPointToMove que definimos como 
PURA. 
 
 
Agora para fechar com chave de ouro usamos tudo isso para realizar o MoveTo:A que distância do player devo ficar em guarda? Ou sair da guarda? 
Neste ponto temos então uma posição para o inimigo seguir e ficar sempre ao redor 
do player certo? Bem ... com esse ponto a nossa inimiga irá se afastar quando o 
player se aproximar dele, e ira perseguir quando o player se afastar. 
Se percebermos la no início fizemos com que o ocorra o EndOverlap o estado mude 
para perseguição, portanto caso o jogador saia correndo para longe do inimigo esta 
ira sair do modo guarda e entrar em modo perseguição com isso controlamos como 
ele irá agir mudando apenas o estado dele legal né :) 
 
Quando que eu posso atacar? 
Agora vamos atacar a última pergunta :P, lembra aquela outra Sphere de raio 200 
com que criamos ? Então agora que iremos usá-la. 
 
Ela servirá para determinar se o inimigo está próximo o suficiente para atacar ou 
não o nosso jogador. 
Primeiramente ative o BeginOverLap e EndOverlap para chamarmos a função 
“EnterAreaOfAttack” do CH_IA3. 
 
 
em seguida implemente essa função para que altere a variável AreaOfAttack no 
controlador da ia da seguinte forma. 
 
 
Faça a mesma coisa para o EndOverlap, porém definindo a variável para false. 
 
 
Agora nossa ia sabe se pode ou não atacar o player. 
Vamos agora criar o input para que o player consiga se defender do ataque do 
inimigo, indo em Edit->Project Setting->Input onde iremos definir um novo action 
mapping chamado Defence. 
 
Logo em seguida vamos definir as mudanças de estado das variáveis quando está 
recebendo dano usando um custom event. 
As mudanças serão feitas com o término das animações por isso estamos usando os 
delay pois já iremos trabalhamos com elas. 
 
 
Vamos ver agora a lógica da IA para o ataque pois ela já sabe que pode atacar. 
Para ela atacar vamos fazer com que no estado de OnGuard a cada um certo tempo 
a ia tente atacar o player somente se estiver na área de ataque. 
 
 
Caso ela seja apta a atacar vamos chamar o nosso custom evento “TryAttack” que 
irá validar mais algumas condições de ataque que são: 
• Não posso atacar se PrepareForDefence for True pois alguém já está 
atacando o jogador. 
• Também não posso InFight for true pois ele está lutando com alguém. 
• E muito menos posso atacar caso alguém esteja batendo dele pois InDamage 
essa true nessa hora. 
 
 
 
Caso tudo esteja liberado posso atacar e, portanto, irei avisar o player que eu estou 
atacando e irei mudar para o estado Fighting 
 
 
Vamos agora ver como trabalhar com o estado de luta, nele vamos fazer com que o 
inimigo ande até próximo do player no caso 2 segundos, que também é o tempo que 
ele terá para se defender. 
Caso o jogador não clique com o botão direito do mouse neste tempo a variável 
InFight estará como false então poderemos aplicar dano ao player. 
 
Neste momento iremos executar a animação e como feedback mudamos de estado 
quando ela terminasse, mas como isso será feito logo mais vamos usar um delay 
para simular o tempo da animação e recolocar o estado do inimigo para OnGuard 
dando assim chance de outro inimigo atacar. Temos de fazer essa mudança de 
estados também quando o player conseguir se defender bem como resetar as 
variáveis de controle. 
 
 
A função damage que chamamos aqui na verdade é o Custom event e que fizemos 
logo acima. 
Nossa configuração final ficou então desta forma, com poucos arquivos, e uma lógica 
simples conseguimos fazer um sistema bem interessante em que você pode 
melhorar as verificações, dando mais liberdades para a inteligência artificial e 
deixando assim seu jogo mais dinâmico e divertido. 
 
 
 
Experimente agora dar o play no jogo e ver ele funcionando com as mensagens. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução a interface Gráfica 
Wedgets 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução a Interface Gráfica 
Widgets 
Neste capítulo veremos como configurar a interface gráfica de nossos projetos 
através da criação e edição do Widget Blueprint. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Configurações Iniciais 
Para este exemplo poderemos ter como base um dos projetos já iniciados 
anteriormente. 
GUI 
A Interface gráfica de um game tem a missão de comunicar ao jogador sobre sua 
estrutura, através de menus interativos, e como essa mesma estrutura pode ser 
explorada, conquistando achievements, abrindo pontos para os próximos 
upgrades, expandindo os itens do inventário e assim por diante. É muito comum ao 
vermos informações sobre a parte artística de produção de games ouvirmos o 
termo GUI, trata-se da abreviação de “Graphical User Interface”. 
A Engine Unreal 4 possui uma ferramenta exclusiva para a criação e dição de GUI, 
chama-se Widget Blueprint. 
 
Para criar uma nova Widget, clique com o botão direito do mouse em algum espaço 
vazio de uma das pastas no Content Browser e siga o caminho indicado na imagem 
a cima. Para o nosso exemplo iremos nomear a Widget como “GUI01”. 
A baixo vemos Widget editor, nele nós temos 2 abas principais para trabalhar: 
Design e Graph, ambas podem ser acessadas na parte superior direita do editor. 
 
 
Vamos voltar a aba Design. Esse espaço retangular no centro da tela nos indica nossa 
área de canvas, do lado esquerdo nós temos a aba Palette, esta possui diversos 
elementos que podemos arrastar para a nossa área de canvas. Entre os elementos 
dentro de Palette nós temos: bordas, botões, imagens, barras progressivas, textos... 
etc. 
 
 
 
Vamos arrastar um botão para o canvas. 
 
Ao fazê-lo notamos que o painel Detail agora possui informações da propriedade 
deste elemento gráfico. 
Vamos fazer um pequeno teste para habilitar alguns elementos gráficos em nosso 
gameplay. Aumente um pouco o tamanho do botão que está no canvas e ponha sobre 
o mesmo um texto “HUD Funcionando”. 
 
 
Vá agora ao Event Graph do Open Level Blueprint, no Level Editor, e lá chame o nó 
“Create Widget”. 
 
Nele iremos selecionar o Widget que acabamos de criar. 
 
 
 
O nó “Add To Viewport” fará com que a interface seja reproduzida enquanto 
jogamos. 
 
Ótimo, o nosso Widget está funcionando perfeitamente, porém já que definimos a 
programação do mesmo no Open Level Blueprint, ele funcionará apenas nessa fase, 
mas e se o nosso projeto possuir várias fases? Para que não precisemos reproduzir 
os códigos em todos os Open Level Blueprints de todas as fases devemos criar agora 
uma nova classe Blueprint denominada HUD. 
 
 
 
Iremos denomina-la como “HUD_BP”. Clique duas vezes no ícone da 
nova HUD. 
 
 
Reproduza o mesmo código que havia sido feito anteriormente no Open Level 
Blueprint, tenha certeza que este último não possua mais o mesmo código, deixando 
apenas no HUD_BP. Pronto, isso garantirá que o Widget seja lido pelo HUD, porém 
para que ela funcione em todos os levels devemos acessar nosso GameMode e lá 
dizermos que a HUD do game será nossa HUD_BP. 
Abra agora Project Sethings e acesse HUD Class. 
 
 
Selecione ai nossa HUD_BP. 
Dessa maneira a HUD funcionará em todas as fases de nosso game, pois adicionando 
ao nosso Game Mode, definimos como regra de todas as fases que usarem esse 
GameMode. 
 
 
Sistema de Health 
Vamos agora demonstrar como é a programação do Widget, criando uma barra de 
vida e um sistema de dano. 
Continuando de onde paramos no exemplo anterior, entre na classeblueprint do 
Player, no Event Graph, crie 1 variáveis Float, chamada de Current Health, depois 
monte o esquema a seguir. 
 
Neste esquema dizemos que qualquer coisa que cause dano no nosso player 
reduzirá o valor da variável Current Health. Agora vamos ao nosso Widget, 
denominado GUI01. 
 
 
Arraste uma Progressive Bar para o canvas, clique no símbolo que parece uma rosa 
e com ele selecionado vá no painel Detail e escolha o modelo superior central em 
Anchors: 
 
Para que nosso Health fique no centro exato, va no eixo X de Aligment e ponha 0.5. 
 
 
Agora com a barra selecionada clique em Binding no painel Detail isso criará uma 
função para interagirmos com Percent. 
 
Dentro do novo Binding criado monte o seguinte esquema: 
 
O código ai incerido estabelece a condição da propriedade “Percent” ser alterada, é 
ela que fará a barra descer ou subir. Estamos determinando que o que retornará o 
velor de Percent será a variável Current Health (criada no player) dividida por 100 
(para encontrar o nó Float / Float na busca por nós digite apenas a barra “/”). 
Feito isso agora vamos para a View Port criar um agente que tire dano de nosso 
player. No painel Modes aba Volumes há um desses que se chama “Pain Causing 
Volume”, arraste-o para o level. 
 
Podemos configurar esse volume diretamente no painel Detail para que tire dano de 
nosso player. Na aba Pain Causing já 2 opções que usaremos: 
• Damage Per Sec: essa determina quanto o Health de nosso player Descerá a 
cada intervalo de tempo definido por Pain Interval. 
• Pain Interval: determina o intervalo de tempo que o dano ocorrerá, por 
exemplo, caso escolhamos aqui 1.0 e em Damage Per Sec 0.3, isso significa 
que a cada 1 segundo a vida descerá 3 pontos, dentro da área do Volume. 
 
 
Este volume aparecerá invisível no game quando dermos play, por isso para 
identifica-lo vamos colocar a partícula de fogo no seu centro. 
 
Ao entrarmos no modo game e entrarmos na área correspondente ao Volume 
notamos nosso Health descendo. 
 
 
Quando saímos da área a barra permanece baixa. Vamos criar agora uma classe 
blueprint que usaremos como um Kit Médico, ou algo do tipo, para aumentar 
novamente nosso Life. 
Criando Regenerador de Health 
Ponha um Mesh da aba Basics em nosso Level para ser o nosso regenerador de vida. 
Atribua a ele um material do seu agrado. 
 
Transforme o retângulo em uma classe Blueprint e vá até sua viewport. Adicione um 
Box Collision em sua composição clicando em Add Components. 
 
 
Vá agora para o seu Event Graph e com o Box selecionado chame o nó 
OnCompenteBeginOverlap. 
 
Depois chame o “Cast to” correspondente ao seu player traga a variável “Current 
Health” tanto Get como Set. Coloque condição de Current Health Set o nó float + float 
e monte o esquema da seguinte maneira. 
 
 
Ao colidir com o Box Collider Current Health receberá 10 pontos de Life e este objeto 
será destruído. 
Espalhe algumas Classes Life pela fase. 
 
Ao darmos play e ficarmos na área do fogo notamos nossa vida descendo, porém ao 
sairmos e encontrarmos um dos retângulos, quando encostamos nos mesmos 
nossa barra de vida sobe um pouco e o retângulo desaparece. 
 
 
 
 
 
E assim concluímos o nosso sistema de perda e recuperação de Health. 
 
 
 
Conclusão 
 
E aqui chegamos ao fim... esperamos que você tenha aprendido muito conosco. 
Quando criamos a apostila pensamos em uma forma de passar tanto conhecimentos 
técnico da ferramenta, como a resolução de problemas e otimizações no projeto 
mostrando formas de fazer e o porquê de fazer deste ou daquele jeito. Um abraço e 
nos vemos na indústria de jogos digitais! 
 
 
 
 
 
 
 
 
Referência Bibliográfica 
 
 Unreal Engine 4 Documentation - https://docs.unrealengine.com/latest/INT/