Criar um inimigo

Nesta parte do tutorial, você criará um inimigo que detecta, persegue e causa dano ao jogador. Além disso, o inimigo poderá receber dano e explorar o ambiente para evitar obstáculos usando uma malha de navegação.

Primeiro, você criará a lógica do inimigo usando o sistema de script visual de Blueprint, como nos tutoriais anteriores. Em seguida, crie a malha de navegação para definir o ambiente que a IA pode explorar. A malha de navegação define as zonas e áreas específicas do mapa em que os vários personagens de IA podem navegar durante o jogo.

Como criar um inimigo

Além do trabalho feito nos Blueprints nos tutoriais anteriores, desta vez você adicionará um objeto para representar visualmente o inimigo e reproduzir uma animação usando um Blueprint de animação. O Blueprint de animação é fornecido nos arquivos do projeto. Portanto, você não o criará do zero. Mas é importante aprender a integrá-lo ao Blueprint do personagem inimigo.

Primeiro, crie o Blueprint do inimigo. Siga as etapas abaixo:

1. Vá para o Navegador de Conteúdo e acesse Conteúdo > AdventureGame > Blueprints > Personagens.

2. Clique com o botão direito do mouse em qualquer lugar vazio, no Navegador de Conteúdo, e clique em Classe de Blueprint.

3. Na nova janela, selecione "Personagem" como a classe-base.

4. Dê o nome "BP_Enemy" para esta classe e abra-a no Editor de Blueprint clicando duas vezes nela.

Ao criar um Blueprint, você também cria uma classe de Blueprint, que faz parte do ativo de Blueprint e define a funcionalidade de um Blueprint. Quando adiciona uma funcionalidade, você está editando a classe de Blueprint. Neste caso, você está criando um ativo de Blueprint chamado "BP_Enemy", que usa o mesmo nome para a classe de Blueprint.

A classe-base pode ser vista como um modelo com funcionalidade prontas que sua nova classe de Blueprint pode usar. Neste caso, a classe-base Personagem tem uma funcionalidade relevante para um personagem de jogo, como movimento e rotação da câmera para o olhar. Usando essa classe-base, você pode usar a funcionalidade pronta sem precisar recriá-la.

O Blueprint do jogador, BP_AdventureCharacter também usa a classe-base Personagem. Dessa forma, tanto o personagem jogável equanto o inimigo terão as mesmas funcionalidades básicas que você pode reutilizar.

Com a janela do Blueprint BP_Enemy aberta, entre na aba Janela de Visualização e confira o painel Componentes. Você verá um componente de movimento de personagem (CharMoveComp) na parte inferior da lista. Esse é o componente que tem suas próprias funções e variáveis relacionadas ao movimento, como a velocidade máxima de movimento, que faz parte da classe-base Personagem. Você pode usar esse componente ao criar uma funcionalidade semelhante para os inimigos no projeto.

Como adicionar um modelo 3D ao inimigo

Primeiro, vamos adicionar um novo componente. Siga as etapas abaixo:

1. Selecione o componente Malha do Esqueleto e procure no painel Detalhes no lado direito da janela. Localize a categoria Malha e clique no menu suspenso ao lado de "Ativo de malha do esqueleto".

2. Pesquise e selecione o modelo SKM_Manny_Simple na lista. Isso atribuirá o modelo de Manny ao Blueprint.

3. Em seguida, confira a categoria Animação. Clique no menu suspenso ao lado de "Classe da animação" e atribua o Blueprint de animação ABP_Unarmed. ABP, neste contexto, significa Blueprint de animação.

4. Modifique o Blueprint de animação para funcionar corretamente com o inimigo:

   1. Na propriedade "Classe de animação" da malha do inimigo, clique em "Acessar o ativo no Navegador de Conteúdo" ao lado de ABP_Unarmed.

   2. Clique duas vezes no Blueprint de animação ABP_Unarmed para abri-lo.

   3. Vá para o grupo de lógica que vem depois do pin Then 1 do nó Sequence. Você não quer que a verificação da aceleração impeça o movimento dos inimigos. Portanto, remova o fio entre o nó And e o nó Set Should Move.

   4. Conecte o pin de saída do nó Greater than (>) a "Should Move" Set Should Move, ignorando a verificação de aceleração.

      

   5. Salve, compile e feche o Blueprint.

Agora o inimigo deve executar uma animação de ociosidade na aba Janela de Visualização.

Em Janela de Visualização, você poderá ver uma forma de cápsula ao redor do personagem inimigo. O componente de cápsula é uma representação visual do colisor de colisão que pode ser usado para detectar colisões com outros objetos, como paredes, chão e o personagem jogável.

Na janela de visualização, veja que o personagem está deslocado do nível do solo e não está alinhado com o componente de cápsula. Isso pode causar desalinhamento durante o jogo. Para garantir que a malha do personagem está alinhada corretamente com o componente de cápsula, mova o personagem para baixo de forma que os pés toquem na parte inferior do componente de cápsula.

Selecione o componente Malha mais uma vez para destacar o modelo 3D. No painel Detalhes, use o campo Posição da categoria Transformação para alterar o eixo Z, que é o último campo azul. Defina o valor como -96. Isso moverá a malha para a parte inferior do colisor de cápsulas, garantindo que o inimigo não flutue acima do solo no jogo.

Certifique-se de que a face frontal do personagem está voltada para a direção da seta azul, que pode ser vista no painel Componentes como o componente de seta (Arrow). A seta mostra em que direção está a face frontal do Blueprint. 

No painel Componentes, você verá um componente de seta. Essa seta também é vista na aba Janela de Visualização como uma seta azul-claro.

O componente de seta indica a direção para a qual o personagem deverá estar voltado para se mover em todas as direções corretamente. A direção da seta é a direção frontal do personagem. 

Com isso em mente, selecione o componente Malha novamente e gire o personagem no eixo Z pelo painel Detalhes, que é o último campo abaixo de Transformar. Talvez seja bom defini-lo -90, para girar corretamente.

Alterar o material do modelo 3D

Antes de passarmos para a criação da funcionalidade, mudaremos a cor do modelo do inimigo para vermelho. Isso o diferenciará do jogador e fará com que pareça mais um inimigo, em vez da cor branca atual.

Na seção Materiais do painel Detalhes, você verá dois elementos. MI_Manny_01_New é o material que afeta várias partes do modelo do inimigo, como braços, pernas e cabeça. MI_Manny_02_New é o material que afeta os antebraços e o tronco.

1. Ao lado da propriedade Elemento 0, clique no botão Pesquisar no Navegador de Conteúdo, que se parece com uma pasta e uma lupa. Isso abrirá a Gaveta de Conteúdo e direcionará até o material selecionado. Perceba que o segundo material, MI_Manny_02_New, também está aqui.

2. Clique com o botão direito no ativo MI_Manny_01_New e clique em Criar instância de material. Isso criará uma instância do material selecionado. Uma instância de material herdará tudo do material-pai, e você poderá substituir os parâmetros que quiser modificar. Por exemplo, você pode alterar a cor, mas manter todas as outras configurações, como o brilho do material, inalteradas.

   Ao criar uma instância de material, a Unreal Engine atribuirá automaticamente um nome ao novo ativo usando o prefixo MI. Neste caso, MI significa instância de material. Você pode criar uma instância de um material ou uma instância de material para ramificação com base em materiais existentes. 

3. Dê o nome MI_Enemy_01 para o ativo da instância de material e clique duas vezes nele para abri-lo.

4. No painel Detalhes à direita, expanda 01 -BaseColor e alterne a propriedade Matiz da tinta. Clique na amostra de cor perto a propriedade "Matiz da tinta" e selecione a cor vermelha ao usar a janela Seletor de Cores.

   Para este tutorial, escolhemos uma cor vermelha vibrante, que você pode usar colando o código de cor F60E6EFF no campo Hex sRGB, no canto inferior direito do seletor de cores.

5. Clique no botão Salvar, no canto superior esquerdo da janela Material, e feche-a.

6. Em seguida, vá para o Navegador de Conteúdo novamente. Desta vez, clique com o botão direito no ativo MI_Manny_02_New e clique em Criar instância de material. 

7. Dê o nome MI_Enemy_02 para a instância de material e repita as etapas anteriores neste material.

Depois de repetir as etapas, você terá duas novas instâncias de material: MI_Enemy_01 e MI_Enemy_02. Lembre-se de salvar seus dois ativos de instância de material ao usar o botão Salvar nas janelas Editor de Material.

Em seguida, atribua esses materiais ao personagem inimigo. Abra o Blueprint BP_Enemy na janela Editor de Blueprint e, no painel Detalhes, vá até a seção Materiais. Clique no menu suspenso para Element 0 e selecione o novo material que você criou: MI_Enemy_01. Para Element 1, selecione o material MI_Enemy_02.

Seu personagem inimigo agora deve estar vermelho, usando os novos ativos de instância de material.

Configurar o inimigo quando o jogo começar

Com o inimigo pronto visualmente, vamos criar a funcionalidade de jogabilidade. Primeiro, você configurar as propriedades do inimigo necessárias para quando ele surgir.

Siga as etapas abaixo:

1. Na janela do Editor de Blueprint BP_Enemy, vá para a aba EventGraph, localizada ao lado da aba Janela de Visualização. Por padrão, você terá três eventos com comentários em cima deles: Event BeginPlay, Event ActorBeginOverlap e Event Tick. Selecione o ActorBeginOverlap e exclua-o, pois não é necessário para este tutorial.

2. Primeiro, usando o painel Componentes, arraste o componente Movimento do Personagem para o Event Graph. Isso criará um nó chamado Character Movement. Arraste o pin desse nó e crie um nó Set Max Walk Speed.

3. Clique com o botão direito no pin verde Velocidade máxima de caminhada do nó Set e selecione a opção Promover a variável. Isso criará uma nova variável, que ficará visível no painel Meu Blueprint à esquerda do Editor de Blueprint, na lista Variáveis.

4. Renomeie esta variável como Max Speed. Clique no ícone do olho perto da variável para torná-la uma variável pública e editável. Compile o Blueprint e, no painel Detalhes, defina o valor padrão da velocidade máxima como 200.

   Como essa variável é pública, você pode definir o valor dela no nível ao adicionar um inimigo. No entanto, se você esquecer de alterar seu valor e o valor padrão estiver definido como 0, o inimigo não poderá se mover. Ao definir o valor padrão como 200, você garante que o inimigo terá velocidade de movimento suficiente para se mover.

5. Na lista Variáveis, adicione uma nova variável chamada CurrentHP do tipo Float.  

6. Adicione mais uma variável chamada Eliminated e mude o tipo para Booleano.  

7. Arraste a variável CurrentHP da lista Variáveis para o Event Graph e clique na opção "Definir PV atuais" no menu de contexto. Arraste o pin Exec do nó Set Max Speed e conecte-o ao pin Exec do nó Set Current HP.  

   

8. No nó Set Current HP, clique com o botão direito no pin de float Current HP e clique em Promover a variável.

9. Renomeie esta variável como TotalHP. Defina o tipo dela para Float e clique no ícone de olho para torná-la pública e editável. No painel Detalhes, defina a Categoria para Configuração. Compile o Blueprint e defina o valor padrão como 100.

     É importante ter duas variáveis que monitoram o valor de vida do inimigo. Como uma variável, Total HP armazenará o nível de vida inicial do inimigo, e a variável CurrentHP monitora quanta vida o inimigo tem no momento, mesmo após receber dano do jogador. Tornar pública a variável Total HP permitirá que você ajuste esse valor em cada instância de um Blueprint de personagem inimigo no nível, o que significa que você pode ajustar a resistência de cada inimigo para tornar cada inimigo mais difícil ou mais fácil para o jogador derrotar.

10. Você realizará muitas ações com o personagem jogável neste gráfico de evento. Em seguida, salve uma referência ao jogador como uma variável. Na lista Variáveis, crie uma nova variável chamada PlayerRef e mude seu tipo para Personagem (referência de objeto).

    

    Criar uma variável de referência para o objeto personagem é melhor para o desempenho do projeto do que chamar a função Get Player Character cada vez que precisar referenciar o jogador.

11. Após o nó Set Current HP, conecte um nó Set PlayerRef. Conecte um nó Get Player Character ao pin de entrada "Referência de jogador". Defina o valor de Índice de jogador deste nó como 0. Este é o índice padrão para o primeiro personagem jogável que surge no nível.

12. Conecte a lógica que você criou ao nó da função Event BeginPlay. O EventGraph deve ficar assim:

    

Fazer o inimigo perseguir o jogadorT

Em seguida, você criará a lógica para mover o inimigo em direção ao jogador. Para isso, crie um evento personalizado, semelhante aos outros nós de evento, como BeginPlay, mas um personalizado que pode ser chamado de qualquer ponto do Blueprint sem precisar recriar a lógica.

Para criar um evento personalizado, siga estas etapas:

1. Clique com o botão direito em qualquer lugar no gráfico de evento e digite Evento personalizado no campo de pesquisa. Clique na opção Adicionar evento personalizado na lista e dê o nome MoveToPlayer para o evento.

2. Arraste o pin do nó de evento MoveToPlayerrecém-criado e insira IA MoveTo no campo de pesquisa. Selecione o nó AI MoveTo para criá-lo. 

   O nó AI MoveTo é um evento que os pawns com AIController podem usar para se mover para um local específico. Neste caso, você o usará para mover o inimigo até o jogador.

3. No nó IA MoveTo, arraste o pin Pawn e insira Próprio no campo de pesquisa. Selecione a opção Obter referência para si para criar um nó que se refira ao ator desse Blueprint no jogo.

4. Em seguida, arraste o pin Ator-alvo do nó AI MoveTo e crie um nó Get PlayerRef.

Nesse caso, você define o Pawn como este inimigo usando o nó Self, usado para definir o ator que se moverá. Em seguida, defina o ator-alvo, que é o alvo para onde o Pawn se moverá, como o personagem jogável no nível.

O nó AI MoveTo contém eventos Ao Ter Sucesso e Ao falhar. Você os usará para definir o que acontecerá se o inimigo alcançar o jogador ou falhar.

1. Arraste o pin Ao Ter Sucesso e crie um nó Delay.

2. Clique com o botão direito no pin Duração do nó Delay e selecione Promover a variável.

3. Dê o nome WaitAtDestination para a variável, que terá o tipo definido como Float por padrão.

4. Compile o Blueprint, selecione a variável WaitAtDestination e altere o valor padrão para 5. Clique no ícone do olho para torná-lo editável e altere sua Categoria para Configuração.

5. Em seguida, no Event Graph, arraste o pin Execução do nó Delay e crie um nó Move To Player. Isso resultará no evento Mover para jogador que você criou sendo executado mesmo que o inimigo alcançasse o jogador, mas após um certo período de tempo.

6. Em seguida, no nó IA MoveTo, arraste o pin Ao falhar e crie um nó Delay. Arraste o pin Concluído deste nó e crie um nóMove To Player. Deixe o campo Duração do nó Delay em 0,2.

Isso garantirá que o inimigo continuará se movendo mesmo quando não alcançar o jogador.

Vamos revisitar o nó Event BeginPlay. Ao fim da sequência, conecte um nó Move To Player no nó Set Player Ref para acionar o evento. Isso faz com que o inimigo se mova no início do jogo para que você possa testar o movimento do inimigo.

Deve ficar assim:

O seu Blueprint completo deve ficar assim:

Como causar dano ao jogador

Agora, aplicaremos dano ao jogador se o inimigo chegar até jogador. Neste tutorial, você criará um inimigo que se autodestrói ao entrar em contato com o jogador. Portanto, você adicionará uma lógica para remover esse inimigo após ele causar dano ao jogador.

Siga as etapas abaixo:

1. No painel Componentes, selecione o componente de cápsula (CollisionCylinder).

2. No painel Detalhes, na seção Eventos, use Adicionar (+) perto de On Component Hit. 

   

   Isso cria um nó de evento no Event Graph que é executado quando o componente, neste caso o componente de cápsula que você selecionou, atinge algo.

3. Arraste o pin do nó On Component Hit e crie um nó Branch. Arraste o pin Condição do nó Branch e arraste-o até o pin Outro ator do nó On Component Hit, que solicitará a criação de um novo nó.

4. Crie um nó Equal que verifica se o outro ator detectado pelo nó On Componente Hit é o ator pretendido, neste caso, o personagem jogável. Arraste a partir do pin Selecionar ativo do nó Equal e adicione uma referência à variável PlayerRef.

   Isso acionará um evento quando o componente de cápsula do inimigo atingir algo no jogo. Esse evento verificará se o outro objeto atingido pelo componente de cápsula é o personagem jogável. Usando essas informações, aplica o dano ao jogador.

5. Neste tutorial, você criará um inimigo que atinge o jogador uma vez e se autodestrói. Para garantir que o dano será causado ao jogador apenas uma vez, arraste a partir do pin Verdadeiro do nó Branch e crie um nó Do Once.

6. No pin Concluído do nó Do Once, crie um nó Apply Damage. Arraste o pin Ator que recebeu o dano e conecte uma referência à variável PlayerRefpara atribuí-lo como o ator que deverá receber o dano.

7. Em seguida, clique com o botão direito no pin Dano-base e selecione Promover a variável. Na lista Variáveis, clique no ícone do olho de Dano-base para torná-lo editável e altere a Categoria de para Configuração. Compile o Blueprint e defina o dano padrão como 25.

8. Em seguida, arraste a variável Eliminação da lista Variáveis para o Event Graph e selecione Configurar.

9. Conecte o pin Execução do nó Apply Damage a nó Set Eliminated.

10. Alterne a propriedade Eliminação do nó Set Eliminated para verdadeiro.

11. Arraste o pin Execução do nó Set Eliminated e crie um nó Delay. Defina a Duração como 2,0.

12. Em seguida, arraste o pin Execução do nó Delay e crie um nó Destroy Actor. A propriedade Alvo deve ser definida como Próprio por padrão.

Quando o inimigo colide com o jogador, ela aplica dano ao jogador e mata o inimigo após um atraso de 2 segundos.

Nesta fase, o inimigo pode correr em direção ao jogador, causar dano e se autodestruir se esbarrar nele. No entanto, isso não leva em conta a distância entre o jogador e o inimigo, nem se há algum obstáculo entre os dois, como paredes. O inimigo sempre perseguirá o jogador, aconteça o que acontecer.

Adicionar lógica de distância e obstáculo

Na seção Próximo deste documento, você verá como definir uma distância máxima de detecção para que o inimigo só possa detectar o jogador quando estiver perto o suficiente dele. Por fim, você criará uma funcionalidade que impede o inimigo de ver o jogador através das paredes. Portanto, o jogador deve estar na linha de visão direta do inimigo para ficar visível. Para fazer isso, primeiro crie uma função na biblioteca de Blueprints que cria um traçado de linha entre o inimigo e o jogador.

Calcule a linha de visão e a distância com um traçado de linha

Um traçado de linha é uma prática comum no desenvolvimento de jogos. O traçado de linha desenha uma linha invisível que parte do ator de origem, cruza e detecta outros objetos e atores do jogo no tempo de execução. Você pode usar os atores e objetos do jogo detectados pelo traçado de linha para ativar a lógica do jogo. Neste tutorial, demonstraremos uma configuração que usa um traçado de linha do personagem inimigo, que irá detectar quando o personagem jogável está na linha de visão do personagem inimigo. Para obter mais informações sobre traçados de linha, consulte a documentação "Traçados com projeção de raios".

Para definir uma função que usa um traçado de linha para testar a distância e a linha de visibilidade do jogador, siga estas etapas: 

1. No Navegador de Conteúdo, vá para a pasta Core e abra a biblioteca de Blueprints BPL_FPGame.

2. Adicione uma nova função chamada fnBPLFindPlayer.

3. No painel Detalhes da nova função, vá até a seção Entradas, das propriedades, e use Adicionar (+) para adicionar os seguintes tipos de entrada:

   • Referência do jogador (referência do objeto de pawn)

   • Posição inicial (vetor),

   • Distância de detecção máxima (float),

   • Depuração (booleano).

     

     Depois de adicionar essas entradas, você perceberá que o nó da função fnBPLFindPlayer tem pins correspondentes para cada variável.

4. Em seguida, no painel Detalhes da função, vá para a seção Saídas, das propriedades, e use Adicionar (+) para criar uma variável de saída booleana Jogador encontrado.

   

   Depois de adicionar a variável Saída do Jogador Encontrado, será criado um novo nó Return no gráfico com a variável Saída do Jogador Encontrado conectada ao nó Entry.

5. Por fim, no painel Meu Blueprint, vá até a seção "Variáveis locais" e use Adicionar (+) para criar uma variável local PlayerFound (Booleano) e verifique se o valor padrão é falso.

   

Em seguida, você precisará adicionar uma verificação de erro para a entrada do jogador. Para adicionar esta verificação, siga estas etapas:

1. Exclua o fio entre o nó Entry e o nó Return segurando a tecla ALT e clicando no pin de execução no nó Entry ou no nó Return.

2. Crie e conecte um nó Is Valid ao nó de entrada da função. Depois de criar o nó, arraste o pin de referência do jogador do nó Entry e conecte-o ao pin "Objeto de entrada" no nó Is Valid. Is Valid é uma função de biblioteca que qualquer Blueprint pode usar, e a referência do jogador é fundamental para que essa função seja executada corretamente, então adicione uma condição para uma referência de jogador inválida para evitar erros.

3. Conecte o pin de execução de Is Not Valid ao Return Node. Conecte uma referência à variável PlayerFound como o valor encontrado. Isso encerra a função, retornando PlayerFound=False para o gráfico de evento do inimigo.

   

Para configurar o traçado de linha, siga estes passos:

1. Se o jogador for válido, a função executará o objeto de traçado de linha e retornará PlayerFound. Adicione um nó Sequence para organizar a lógica.

2. Arraste a partir do pin Then 0 do nó Sequence e adicione um nó Line Trace By Channel. Observação: saiba mais sobre nó aqui. O que é por canal? Qualquer documento para criar um link.

3. Configure o nó Line Trace By Channel:

   • No nó Entry, arraste o pin "Localização inicial" e conecte-o ao pin de entrada "Início" do nó Line Trace By Channel. Isso usará a posição do personagem inimigo como ponto de partida para o traçado de linha.

   • Em seguida, arraste o pin "Referência do jogador" do nó Entry para qualquer lugar no gráfico. Isso abrirá o menu de contexto do nó Blueprints. Usando o menu de contexto, pesquise e crie um nó Get Ator Location. Isso criará um nó usando a referência do jogador como entrada-alvo. Isso encerra o traçado de linha na posição do jogador.

   • No nó Line Trace By Channel, defina a propriedade "Canal de rastreamento" como "Câmera" usando o menu suspenso.

   

Em seguida, crie a funcionalidade para usar o resultado de acerto do traçado de linha para verificar o jogador e a distância de acerto, seguindo estas etapas:

1. Arraste a partir do pin "Out Hit" do nó Line Trace e adicione um nó Break Hit Result. Quando um traçado de linha atinge um objeto, muitas informações são coletadas. Para essa lógica, precisamos usar apenas alguns valores específicos. Portanto, um nó Break Hit Result é necessário para dividir os dados nos componentes individuais do nó dados retornados.

2. No nó Break Hit Result, clique na seta, na parte inferior, para ver mais opções. O objetivo dessa função é determinar se o jogador está na linha de visão e dentro de uma certa distância do inimigo. Portanto, você usará o "Ator de acerto" para verificar o jogador e "Início de rastreamento" e "Fim de rastreamento" para medir a distância até o objeto atingido.

3. Arraste do pin "Ator de acerto" e adicione um nó de operador Equal. Para a entrada inferior, conecte uma referência à entrada da função Player Reference.

4. Crie um nó Distance (Vector). Conecte V1 a "Início de rastreamento" e conecte V2 a "Fim de rastreamento". Observação: um vetor é um conjunto de valores X, Y e Z que representam a posição de um objeto ou ponto no espaço 3D. O nó Distance calcula a distância entre dois desses pontos, o que resulta em um valor float.

5. Arraste do valor de retorno do nó Distance e adicione um nó Less (<). Para a entrada inferior, conecte uma referência à entrada da função Detection Distance.

6. Crie um nó AND (booleano) e conecte as saídas booleanas "Equals (==)" e "Less (<)" aos pins de entrada do nó AND (booleano). Com essa lógica, o nó AND retorna verdadeiro se o traçado de linha atingir um ator que seja igual a Player Reference e a distância entre o início do traçado (o inimigo) e o fim (o objeto atingido) for menor que a distância de detecção máxima.

   

7. Arraste a partir da saída do nó AND, adicione um nó Branche e configure o nó:

   • Conecte-o para ser executado após Line Trace By Channel.

   • No pin de execução "Verdadeiro" do nó Branch, crie um nó variável Set para definir a variável local PlayerFound como verdadeira.

   • No pin de execução "Falso" do nó Branch, crie um nó variável Set para definir a variável local PlayerFound como falso.

   

8. Você terminou a lógica do traçado de linha, então volte ao nó Sequence e conecte o pin Then 1 ao nó Return. para sair da função e enviar o resultado de PlayerFound de volta ao Blueprint de inimigo.

Você quer conseguir ativar e desativar um elemento visual de depuração do traçado de linha no Editor de Níveis. No entanto, o nó Line Trace permite escolher apenas uma opção da lista "Tipo de depuração do desenho". Você pode usar um nó Select para conectar a variável booleana editável Debug a duas das opções de "Tipo de depuração do desenho". 

Para definir uma opção de depuração personalizável para o traçado de linha, siga estas etapas:

1. No pin "Tipo de depuração do desenho" do nó Line Trace By Channel, crie um nó Select.

2. Conecte o pin "Index" do nó "Select" à entrada da função "Debug" do nó "Entry". O índice do nó "Select" é um curinga. Quando você conecta a referência de depuração do tipo booleano, as opções mudam para "False" e "True".

3. Defina falso para None e defina verdadeiro para For Duration.

4. Salve e compile sua função de Blueprint.

   

Essa lógica usará a variável Depuração para determinar se o desenho de depuração do traçado de linha está ativo ou não. Quando a variável Depuração for falsa, o modo de depuração será definido como Nenhum, ou seja, nenhum desenho de depuração será renderizado. Quando a variável Depuração estiver definida como verdadeira, o nó Select habilitará o desenho de depuração por duração, que renderizará o traçado de linha no tempo de execução enquanto estiver ativo. Você também tem a opção de usar outras opções, como For One Frame, que desenha o traçado de linha apenas para um único quadro, ou "Persistente", que deixa o desenho de depuração ativo enquanto o projeto estiver em execução. Nesta instância, "For Duration" é a maneira mais útil de desenhar o traçado de linha durante a depuração.

Fazer os inimigos perseguirem o jogador

Agora que você pode fazer uma chamada de uma função que procura o jogador considerando a distância e a linha de visão, adicionar uma lógica ao inimigo que faça com que ele procure e persiga o jogador. 

Siga as etapas abaixo:

1. No Navegador de Conteúdo, vá até Conteúdo > AdventureGame > Designer > Blueprints > Personagens e abra BP_Enemy.

2. No Event Graph, arraste o pin "Execução" do nó Event Tick e crie um nó Branch. Observação: o evento "Na Marca de Verificação" roda todos os quadros durante a execução do jogo. Use-o para fazer o inimigo verificar constantemente a posição do jogador e determinar se deve começar a perseguição.

3. Arraste o pin "Condição" do nó Branch e crie um nó NOT Boolean, que retorna o inverso de um valor booleano. Neste caso, negue a variável Eliminação, então arraste o pin do nó NOT Boolean e pesquise Get Eliminated.

   

   Isso verificará se o inimigo não foi eliminado e, nesse caso, continuará com o pin "Verdadeiro" do nó Branch.

4. Arraste o pin Verdadeiro do nó Branch e crie um nó FnBPLFind Player. Esse nó realizará um traçado de linha para encontrar o jogador no mundo e verificará a distância atual entre o inimigo e o jogador. 

5. No nó Fn BPLFind Player, faça estas conexões usando os pins:

   • Referência do jogador: conecte uma referência à variável PlayerRef.

   • Posição inicial: crie um nó Get Actor Location com a propriedade Alvo determinada como "self". Isso continuará atribuindo a posição inicial do traçado de linha à posição do inimigo no mundo.

   • Distância de detecção máxima: selecione "Promover a variável", clique no ícone de olho para torná-la editável e mude "Categoria" para "Configurações". Defina o valor padrão como 20000 (200 metros) após compilar o Blueprint. Quanto menor for o valor, mais perto o jogador deve estar para que os inimigos o detectem.

   • Depuração: selecione "Promover a variável" e chame-a de DebugDetection. Torne essa variável editável e visível na categoria "Configuração".

   

Se o jogador for encontrado pelo traçado de linha, defina a velocidade máxima de movimento do inimigo como o valor desejado, movendo-o em direção ao jogador. Caso contrário, defina a velocidade como 0 para que o inimigo não possa se mover em direção ao jogador.

1. No nó FnBPLFindPlayer, clique com o botão direito no pin "Encontrado" e promova-o a uma variável. Isso cria automaticamente um nó Set para essa nova variável. Conecte também o pin de execução do nó. Agora você pode usar o resultado de "Encontrado" em outro lugar no gráfico.

2. Conecte um nó Branch ao nó Set. Arrastar o pin "Condição" do nó Branch ao pin de saída do nó Set Found.

3. No painel Componentes, arraste o "Movimento do personagem (CharMoveComp)" para o Event Graph. Arraste o pin e crie um nó Set Max Walk Speed.

4. Arraste o pin Verdadeiro do nó Branch e conecte-o ao nó Set Max Walk Speed. 

5. No painel Variáveis, arraste a variável "Velocidade máxima" para o Event Graph, selecione Get e conecte-o ao pin "Velocidade máxima de caminhada" do nó Set.

6. Em seguida, duplique nó Set Max Walk Speed e o Character Movement. Conecte o pin "Falso" do nó Branch ao novo nó Set. 

7. Defina a propriedade "Velocidade máxima de caminhada" como 0.

   Isso faz com que o inimigo pare de se mover sem cancelar a tarefa "IA MoveTo" e precisar executar a tarefa novamente.

8. Conecte um nó MoveToPlayer ao nó Set que está conectado ao nó Branch, de modo a chamar um evento e fazer o inimigo se mover apenas se tiver encontrado o jogador.

9. Agora que o inimigo está procurando o jogador a cada quadro, exclua o nó Move to Player adicionado no final da lógica Event BeginPlay. Este nó foi útil para testar um inimigo parcialmente concluído, mas você não precisa mais dele. 

10. Vá até a lógica de evento MoveToPlayer. Agora, o inimigo só executará isso se o jogador for encontrado:

    1. Exclua o fio entre o nó de evento e "IA Move To". Conecte um nó Branch entre esses dois nós, usando o pin "Verdadeiro" do nó Branch.

    2. Para a condição do nó "Branch", adicione uma referência à variável "Encontrado".

    

Se o jogador estiver na distância do inimigo determinada e não houver obstáculos entre os dois, a velocidade de movimento do inimigo será definida como a variável MaxSpeed e ele executará a lógica MoveToPlayer. Se alguma dessas condições não for atendida, a velocidade de movimento do inimigo será definida como 0, bloqueando o inimigo de se mover em direção ao jogador.

Permitir que inimigos recebam dano

Antes de encerrar este Blueprint, certifique-se de que o inimigo também pode receber dano. Siga as etapas abaixo:

1. Clique com o botão direito em qualquer lugar no Event Graph e crie um nó Event AnyDamage.

2. Arraste a variável "CurrentHP" ao Event Graph e selecione "Set CurrentHP".

3. Você subtrairá o dano causado de "CurrentHP". Comece arrastando o pin de execução do "Event AnyDamage" e conectando-o ao nó Set.

4. Arraste o pin da propriedade CurrentHP e crie um nó Subtract.

5. Arraste o pin inferior do nó Subtract e conecte-o à propriedade "Dano" do nó evento Event AnyDamage.

6. Em seguida, arraste o pin superior do nó Subtract e crie um nó Get Current HP.

   

Portanto, quando algum dano for causado a esse ator, ele pegará o valor da variável CurrentHP, subtrairá o dano e definirá o valor de CurrentHP como o novo valor.

Em seguida, vamos verificar se CurrentHP é menor ou igual a 0, o que deve matar o inimigo.

1. Arraste o pin do nó Set e crie um novo nó Branch.

2. Arraste o pin "Condição" do nó Branch e crie um nó Less Equal (<=).

3. Arraste o pin superior e crie um novo nó Get CurrentHP. Certifique-se de que a propriedade do pin inferior está definida como 0.

4. Arraste o pin "Verdadeiro" do nó Branch e crie um nó Do Once. Arraste o pin "Concluído" e crie um nó Set Eliminated.

5. No nó Set, alterne a propriedade "Eliminação" para "Verdadeiro".

6. Após o nó set, conecte um nó Delay com "Duração" definido como 2.

7. Por fim, arraste o pin "Concluído" do nó "Delay" e crie um nó "Destroy Ator" com a propriedade "Alvo" definida como "Próprio".

   

Lembre-se de salvar e compilar o blueprint.

Como criar uma NavMesh para a navegação do inimigo

Antes de adicionar o inimigo a um nível e fazê-lo perseguir o jogador, é necessário compilar a NavMesh que a IA do inimigo usará para navegar no nível. 

NavMesh é a abreviação de malha de navegação e pode ser usada para definir as áreas de navegação da IA no nível. Ao criar uma NavMesh neste tutorial, você definirá uma zona na qual o inimigo pode se mover para perseguir o jogador.

Saia do Editor de Blueprint de "BP_Enemy" e vá para o Editor de Níveis na Unreal Engine. Na barra de ferramentas principal, clique no botão Adicionar, vá para Volumes e crie um volume de delimitação de NavMesh. Isso criará um objeto que poderá ser usado para atribuir uma zona navegável à IA no projeto.

Se você não conseguir ver as zonas verdes, pressione a tecla P no teclado para alternar a visualização de depuração. Isso pode ser usado para visualizar os detalhes da NavMesh na janela de visualização do nível, incluindo as zonas navegáveis nele, bem como informações de depuração baseadas em texto no lado esquerdo da janela de visualização do nível.

Usando as ferramentas de Transformação, você pode mover e dimensionar (teclas W e R no teclado) a NavMesh para modificar os limites dela. Dimensione esta zona como quiser. Neste caso, com o objeto NavMeshBoundsVolume selecionado, você deve redimensioná-lo para 6, 7, 1 nos campos X, Y e Z do painel Detalhes, na seção Transformação.

À medida que dimensiona e move a NavMesh, você verá as zonas verdes se expandindo com o tamanho da caixa delimitadora, a menos que tenha alguns objetos que seriam considerados obstáculos, como cubos.

As partes recortadas em vermelho significam que a IA não pode navegar por elas no jogo.

Dica: se o Unreal Editor incluir algo que não deveria na NavMesh, selecione o objeto no nível da malha e desabilite "Pode afetar a navegação" no painel Detalhes.

Adicionar o inimigo ao nível

Depois de criar e definir sua área de NavMesh para seus personagens inimigos, você pode adicioná-los ao nível.

Abra o Navegador de Conteúdo e vá até a localização do Blueprint do seu inimigo. Arraste o Blueprint do inimigo para a janela de visualização do nível e coloque-o na frente do jogador. Certifique-se de que ambos estão nos limites da NavMesh, ou seja, nas áreas verdes.

Selecione o ator inimigo na janela de visualização de nível ou nos painéis do Organizador. No painel Detalhes, você verá as variáveis adicionadas ao Blueprints nas seções das propriedades padrão e das configurações. Você pode alterar esses valores de acordo com as necessidades do projeto ou ativar a variável "Deteção de depuração" para habilitar o desenho de depuração do traçado de linha.

Se você jogar agora, dependendo da distância entre o inimigo e o jogador, o inimigo pode não estar se movendo. Se você se aproximar do inimigo, ele deverá começar a perseguir o jogador. 

Vamos tentar com um obstáculo. Saia do modo de jogo e adicione um cubo no meio da zona verde pressionando o botão "Adicionar" na barra de ferramentas principal e selecionando "Formatos" > "Cubo". Isso executará o ponto de corte, pois um cubo será considerado um obstáculo automaticamente.

Se o jogador estiver atrás desse cubo, o inimigo não poderá persegui jogador, pois o traçado de linha será bloqueado pelo cubo, fazendo com que o inimigo não consiga encontrar o jogador. Se o jogador caminhar ao redor do cubo e o inimigo puder ver jogador, ele continuará perseguindo jogador.

Se algo não funcionar conforme o esperado, confira se as variáveis criadas no Blueprints têm os valores corretos definidos no "BP_Enemy" da cena. Se você não definir os valores de velocidade máxima ou distância máxima de detecção, a IA de inimigo não se moverá. A mesma coisa pode acontecer se os valores forem muito baixos.

Como criar posições de inimigo no projeto

Para o nosso nível de amostra, colocamos vários inimigos no Corredor 3 e na Sala 3. O primeiro inimigo foi colocado sozinho no Corredor 3, isso foi feito para dar ao jogador um primeiro encontro simples, para aprender e se familiarizar com o personagem inimigo e suas habilidades.

Depois de encontrar o único inimigo no corredor, colocamos dois personagens inimigos adicionais na Sala 3 para apresentar um desafio a mais ao jogador. Você pode usar a quantidade e a variação de inimigos para fornecer diferentes níveis de dificuldade ao projeto. A introdução de novos inimigos e desafios aos jogadores cria aos poucos uma curva de dificuldade mais equilibrada, com a qual o jogador pode se acostumar com o tempo. Criar um encontro difícil com o inimigo, depois de permitir que o jogador aprenda a explorar e derrotar os inimigos, fornece um desafio que pode parecer recompensador para o jogador.

Próxima

No próximo módulo, você aprenderá a criar uma mecânica de disparada que o jogador pode usar para navegar por espaços e desafios com maior velocidade. Isso pode ser usado para fazer o jogador se sentir mais eficiente ao navegar pelos espaços, além de dar ao jogador uma ferramenta para evitar os inimigos que você acabou de adicionar ao projeto.

Adicionar uma mecânica de disparada ao jogador

Use ação de entrada (Input Action) para adicionar uma mecânica de corrida aos movimentos do personagem jogável.