Você está na página 1de 313

Sumário  .........................

8
Configurando Player Character........................................... Error! Bookmark not defined.
Configurações Iniciais.................................................................................................... 10
Axis e Action Mappings.................................................................................................. 21
Animation Blueprint........................................................................................................ 51
Blend Space 1D.............................................................................................................. 60
Editando Animações....................................................................................................... 73
Configurando Animação de Pulo.................................................................................... 78
Conclusão...................................................................................................................... 84
Configurando Player Character......................................................................................... 88
Configurações Iniciais.................................................................................................... 90
Axis e Action Mappings................................................................................................ 102
Game Mode.................................................................................................................. 107
Configurando Movimento............................................................................................. 114
Animation Blueprint...................................................................................................... 123
Blend Space 1D............................................................................................................ 133
Editando Animações..................................................................................................... 145
Configurando Animação de Pulo.................................................................................. 152
Conclusão.................................................................................................................... 158
Adicionando Animações.................................................................................................. 160
Template do projeto..................................................................................................... 162
Adicionando Animações Com Animation Motage......................................................... 176
Inteligência Artificial I...................................................................................................... 194
Template do projeto..................................................................................................... 195
Configurando a IA........................................................................................................ 197
Programando a IA........................................................................................................ 202
Questão:....................................................................................................................... 203
Área de atuação “Nav Mesh”........................................................................................ 204
Conclusão.................................................................................................................... 206
Aguçando a curiosidade............................................................................................... 206
Inteligência Artificial II .................................................................................................... 208
Template do projeto..................................................................................................... 209
Lista de Passos:............................................................................................................. 209
Organizando os diretórios............................................................................................ 211
Sistema Chave&Porta / Pontuação I.............................................................................. 214
Criando a porta ............................................................................................................... 221
O elevador ...................................................................................................................... 224
Controle de estados ........................................................................................................ 225
Programação no Player (Jogador) ................................................................................... 227
Sistema Chave Porta / Pontuação II ................................................................................. 228
Chaves ............................................................................................................................ 229
Portas.............................................................................................................................. 229
Elevador ......................................................................................................................... 231
Checkpoint ..................................................................................................................... 233
Zona da morte ................................................................................................................. 235
O inimigo (IA) ................................................................................................................. 237
Subindo níveis! ............................................................................................................... 242
Inteligência Artificial III ...................................................................................................... 248
Template do projeto ....................................................................................................... 250
Lista de Passos: ............................................................................................................... 250
Configuração inicial do projeto....................................................................................... 251
Game design .................................................................................................................. 255
Qual estado eu início ...................................................................................................... 256
Resumo de funções e variáveis ....................................................................................... 258
Existe algum player próximo de mim? ............................................................................ 260
Onde está o player onde irei me posicionar? .................................................................. 265
A que distância do player devo ficar em guarda? Ou sair da guarda? ............................. 272
Quando que eu posso atacar? ......................................................................................... 272
Introdução a interface Gráfica ............................................................................................ 283
Configurações Iniciais .................................................................................................... 286
GUI ................................................................................................................................. 286
Sistema de Health ........................................................................................................... 298
Criando Regenerador de Health ..................................................................................... 305
Conclusão .......................................................................................................................... 312
Referência Bibliográfica...................................................................................................... 313
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 iniciado crie 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 naa 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ã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 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 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.

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.
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.

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 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 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çã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 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.
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.

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.
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ções de 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 isso em 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 interessante que 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 escreva o CustomEvent Jogador Detectado criando este evento na aba EventGraph da mesma forma que fizemos com a
chave e moeda.

Crie uma variável pública com o nome MinhaChave do tipo A_Chave, esta será a chave da porta e no fim tudo deverá ficar da
seguinte forma.
Agora posicone varias moedas na cena, uma porta e uma chave, estamoa usando apenas uma chave mas voce podera usar quantas
portas e chaves desejar.
Posicione uma chave na cena bem como várias moedas espalhadas:
O elevador
Vendo a imagem acima chegamos a um ponto no cenário que não conseguimos chegar ao patamar de cima, para conseguirmos
vamos construir um elevador, vamos aos passos então.

1. Crie um novo ator e de o nome de A_Elevador herdando A_ObjetoBase


2. Adicione um StaticMesh, e defina a mesh como 1M_Cube
3. Reposicione e redimensione o Detector
4. Realize a sobre escrita do CustomEvent Jogador Detectado

Controle de estados
Quando nosso player morrer devemos diferenciar se ele morreu na queda ou se morreu pelo inimigo, mas como faríamos isso?
Poderíamos usar uma variável do tipo integer e dizer que caso o valor seja 0 significa que o player morre pelo inimigo, e caso seja
1 ele morreu pela queda, porém essa solução não é interessante pois pode gerar dúvidas e muitos problemas conforme o projeto
comece a ficar maior, imagine 100 estados diferentes sendo definido dessa forma entre diversas classes!
Para isso temos o Enum, nele podemos organizar nossos estados de forma mais clara e organizada.
Com o Enum criado defina seu nome para E_Estados e abra este arquivo criando três estados.

● Vivo o Estado em que o player ainda está vivo


● MortoPeloInimigo o Estado informa que o player morre pelo inimigo
● MortoPorAreaPerigosa o Estado informa que o player morreu por entrar em uma área de perigo,
podemos pensar como sendo Lava, área radioativa ...
Programação no Player (Jogador)
Até o momento construímos a cena e os itens que usaremos no jogo, mas nada de programação... bem isso acaba por aqui vamos
programar!
Vamos iniciar a programação criando o inventario do Jogador, onde guardaremos todas as chaves e o número de moedas que
pegamos durante a fase.
Crie uma variável do tipo A_Chave chamada Chaves e marque-a como lista de A_Chave clicando no quadriculado ao lado do tipo
de variável.
Crie também uma variável do tipo integer chamada Moedas, a usaremos para contar quantas moedas pegamos na cena.
Precisaremos ainda do estado do player então crie uma variável do tipo E_Estados e chame de EstadoAtual.
E por fim teremos um sistema de Checkpoint logo devemos guardar a posição em que ele se encontra para isso vamos criar uma
variável do tipo Vector e chamada de CheckPointEncontrado.
Sistema Chave Porta / Pontuação II
Vamos voltar nossa atenção agora para o cenário, nele deixamos já configurado uma porta e uma chave, assim como várias moedas e
o elevador pelo uso de herança agora só precisamos definir para cada ator o que seu evento Jogador Detectado deve fazer.

Abra o arquivo A_Moeda encontre o CustomEvent Jogador Detectado que criamos e altere sua lógica.
Pegue a variável moedas do nosso jogador e realize o incremento e imprima o novo valor na tela depois destrua o objeto.
Chaves
Abra o arquivo A_Chave encontre o CustomEvent Jogador Detectado que criamos e altere sua lógica.
Pegue a variável Chaves que é uma lista e adicione a própria moeda a essa lista depois mova ela para fora da vista do jogador.

Portas
Abra o arquivo A_Porta encontre o BeginOverlap que criamos e altere sua lógica.
No evento Jogador detectado procure MinhaChave dentro da variável Chaves do caso exista iremos abria a porta.
Adicione uma TimeLine que irá variar de 0 a 90 o nome da variável de saída será AnguloAtual, ela deve ter 2 segundos de duração,
clique com o shift pressionadora criar dois pontos, clique no primeiro ponto de defina o tempo e valor para zero, clique no segundo
ponto e defina seu tempo para 2 e seu valor para 90.
Defina a rotação da porta para ser igual ao valor de saída da TimeLine um Doonce para que seja feita apenas uma vez a ação tudo
deverá ficar como na imagem.
Temos ainda que definir qual chave pertence a nossa porta, para que ela seja aberta caso o jogador tenha a chave.
Selecione a porta que está na cena, vá para o painel de detalhes e no campo default você verá a variável MinhaChave, clique no
conta gotas e depois clique na chave que está na cena assim a chave será atribuída àquele objeto.

Elevador
Ainda não conseguimos chegar até a porta pois o player na pula tão alto, por isso criamos o elevador e iremos programa-lo agora.
Para o evento Jogador Detectado crie uma nova Timeline chamada Subir, que terá duração de dois segundos, crie uma variável
com nome Altitude e dois pontos, o primeiro em time e valor igual a zero e o segundo time igual a 2 e valor igual a 7, para mim
esses valores foram suficientes para que o elevador subisse até o topo adapte para o seu projeto.
Agora para o elevador descer use o evento Jogador Perdido, duplique a TimeLine e multiplique a altitude por menos um, assim o
elevador começara a descer logo que o player sair dele.
Checkpoint
Vamos brincar com o Checkpoint, para isso vamos usar a mesma lógica que usamos para a chave, você se lembra como fizemos?
Crie um novo ator que herde de A_ObjetoBase, defina o ícone
Icone_CheckPoint_Sprite que criamos a partir do Icone_CheckPoint como fizemos coma moeda e chave lembre-se de remover a
colisão do ícone, realize a sobre escrita do evento Jogador Detectado, quando este evento ocorrer pegue a posição do checkpoint
e defina para a variável CheckPointEncontrado do jogador.
Além disso devemos definir a posição inicial do jogador para a variável CheckPointEncontrado pois caso ele morra sem
encontrar um checkpoint esse será colocado na posição (0,0,0), para isso vamos para o Jogador e no evento Beginplayer
definimos o valor da variável como sendo a posição que o player iniciou.

Posicione alguns checkpoints pela cena.


Zona da morte
Para usarmos o nosso sistema de checkpoint temos que morrer primeiro né? Então crie um novo ator chamado A_AreaPerigosa
herdando de A_ObjetoBase assim como no checkpoint adicione um PaperSprite e coloque o ícone
Icone_lancas_Sprite remova a colisão do Sprite.

E vamos repetir o mesmo processo do checkpoint porem agora iremos trocar o estado do player para MortoPorAreaPerigosa e
após um delay de 2 segundos vamos chamar o CustomEvent Jogador Morreu que criaremos no Jogador logo abaixo.
No Blueprint do Jogador crie este CustomEvent que chamamos a variável de entrada é do tipo E_Estados, troque o estado a atual
para o estado que foi passado no parâmetro e depois de 2 segundos reposicione o player para a posição do checkpoint e traga o
de volta a vida.

Assim já mudamos o estado do jogador para morto e podemos trocar a animação dele por uma animação de morte.
Adicione este ator a cena para que o player possa começar a morrer, vejamos como ficou agora.
O inimigo (IA)
Todo o jogo já está funcionando, pegamos moedas, conseguimos abrir portas morrermos em áreas perigosas temos o nosso
inventario.
Vamos então começar a trabalhar nossa inteligência artificial, ela irá perseguir o nosso jogador e matá-lo caso o toque.
Primeiramente vamos repetir o passo da apostila anterior inserindo na cena um “Nav Mesh Bounds Volume” na tab Modes.
Redimensione o volume para que ocupe toda a área do mapa.
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 a
• 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 um inimigo 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. ThirdPersonCharacter 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 classe blueprint 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/

Você também pode gostar