Criar um inimigo

Nesta parte do tutorial, você criará um PNJ inimigo que detecta, persegue e causa dano a alguém. 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 script visual de Blueprint, como nos tutoriais anteriores. Em seguida, crie a malha de navegação para definir as zonas que os personagens possuídos pelo Controle de IA poderão explorar.

Antes de começar

Certifique-se de entender os tópicos abordados na seção anterior de Como projetar uma aventura de quebra-cabeça:

• Blueprints e funções de Blueprint

Você precisará dos seguintes ativos de Criar uma chave:

• Biblioteca de funções do Blueprint BPL_FPGame

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

Para adicionar uma malha de navegação ao nível, siga estas etapas:

1. No Editor de Níveis da Unreal Editor, na barra de ferramentas principal, clique no botão Criar, acesse Volumes e selecione Volume de limites de malha de navegação. Isso cria uma zona navegável para a IA no projeto. 

   

2. Usando as ferramentas de Transformação, mova a NavMesh até a intersecção com o chão no nível.

3. Pressione a tecla P no teclado para alternar a visualização de depuração. Use 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. 

   Se você vir uma mensagem "É preciso recompilar a NavMesh" nas informações de depuração, vá para a barra de menus e acesse Compilar > Compilar caminhos. Sua NavMesh é reconstruída.

4. Continue para mover e dimensionar (teclas W e R no teclado) a NavMesh e modificar os limites dela. Ajuste o volume como quiser. 

   Verifique se a parte inferior da NavMesh está baixa o suficiente para incluir pedaços de chão rebaixados e se a parte superior da NavMesh é alta o suficiente para acomodar a altura do inimigo. 

   Se você estiver usando o nível de amostra do tutorial, crie e dimensione dois volumes de delimitação da NavMesh para preencher o Corredor 3 e a Sala 3.

   

   À medida que dimensiona e move a NavMesh, você verá as zonas verdes se expandindo com o tamanho da caixa delimitadora, a menos que tenha obstáculos, como cubos. As partes recortadas em vermelho significam que a IA não pode navegar por elas no jogo.

Criar um inimigo

Você criará o inimigo com base na classe Personagem, pois já inclui funcionalidades de movimento e animação que fazem sentido para um oponente humanoide. A classe Personagem na verdade estende o Pawn, que é o "ator controlável" mais geral usado para várias coisas, como veículos, câmeras ou criaturas não humanoides. Para inimigos que se parecem com pessoas, o Personagem é o melhor ponto de partida.

Como está criando este personagem do zero, você adicionará uma malha 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. No Navegador de Conteúdo, vá para Conteúdo > AdventureGame > Designer > 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.

Ao criar uma Classe de Blueprint, você escolhe uma classe-pai para construir com base nela. Esse pai já vem com recursos integrados. Por exemplo, ao criar Blueprints com base na classe Ator, você inicia com uma transformação e a capacidade de manter componentes e executar lógica. Agora, começando pela classe de personagem, você também tem suporte para movimento, colisão e animação. Você usa a classe-base de maneira semelhante a um modelo. Ao adicionar uma funcionalidade, você estende a classe-base. 

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. Todas as classes Personagem vêm com um componente de movimento do personagem. Clique no componente e confira o painel Detalhes para ver todas as configurações. Você substituirá algumas dessas configurações ao criar os inimigos no seu projeto.

Como adicionar um modelo 3D ao inimigo

O personagem também inclui um componente de malha, mas, em vez de uma malha estática, esse componente é uma malha esquelética. As malhas estáticas com as quais você tem trabalhado até agora são modelos 3D fixos que não se movem, já a malha do esqueleto inclui um esqueleto interno que pode ser animado e deformado.

Primeiro, configure a malha e as animações do personagem. Siga as etapas abaixo:

1. Selecione o componente Malha e procure no painel Detalhes. Localize a categoria Malha e clique no menu suspenso ao lado de Ativo de malha do esqueleto. Na lista, pesquise e selecione o modelo SKM_Manny_Simple na lista. Isso atribui o modelo de Manny ao Blueprint.

2. No painel Detalhes, vá para a categoria Animação. Clique no menu suspenso ao lado de Classe da animação e atribua o Blueprint de animação ABP_Unarmed. Agora o inimigo deve executar uma animação de ociosidade na aba Janela de Visualização.

   

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

   4. Você não quer que a verificação da aceleração impeça o movimento dos inimigos. Portanto, exclua o fio entre o nó And e o nó Set Should Move.  

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

      

   6. Compile, salve e feche o Blueprint.

Em janela de visualização, você poderá ver uma forma de cápsula cilíndrica ao redor do personagem inimigo. Esta é uma representação visual do componente de cápsula que detecta colisões com outros objetos, incluindo o chão. A malha do personagem tem um formato mais complexo, então um cilindro de colisão simples suaviza o formato para que a colisão seja detectada com melhor desempenho.

A malha está deslocada e desalinhada em relação à cápsula. Para fazer com que a malha do personagem se alinhe 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.

Para alinhar a malha do personagem com o volume de colisão dela, siga estas etapas:

1. Selecione o componente Malha mais uma vez para destacar o modelo 3D.

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

Agora, com os dois componentes centralizados na origem, o inimigo não flutuará acima do solo no jogo.

Por fim, veja que o personagem tem um componente de seta (flecha). A seta indica a direção frontal do Blueprint. Certifique-se de que a seta está alinhada com a direção apontada pela malha para que o personagem corra na direção correta.

Para fazer a malha do personagem ficar de frente, siga as etapas abaixo:

1. Selecione o componente Malha mais uma vez. Use o dispositivo de rotação ou a categoria Transformar do painel Detalhes para girar o personagem 90° no eixo Z. O último valor de Rotação deve ser -90.

Orientação incorreta	Orientação correta

Como 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 público jogador e fará com que pareça mais um inimigo, em vez da cor branca atual.

Para fazer o personagem inimigo ter uma cor diferente, siga estas etapas:

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

2. Ao lado do Elemento 0, clique no botão Pesquisar no Navegador de Conteúdo, que se parece com uma pasta e uma lupa. Isso abre a pasta que contém o material no Navegador de Conteúdo. O segundo material, MI_Manny_02_New, também está aqui.

3. Clique com o botão direito no ativo MI_Manny_01_New e clique em Criar instância de material.

4. Dê o nome MI_Enemy_01 para a instância de material e clique duas vezes nela para abri-la.

5. No painel Detalhes, expanda 01 -BaseColor e habilite a propriedade Matiz da tinta.   

6. Clique na amostra de cor perto da propriedade Matiz da tinta e selecione uma cor. Este tutorial usa Hex sRGB = F60E6EFF.

   

7. Clique em Salvar e feche a janela.

8. Volte para o Navegador de Conteúdo, clique com o botão direito em MI_Manny_02_New e clique em Criar instância de material.

9. Dê o nome MI_Enemy_02 para a instância de material e repita as etapas anteriores para mudar a cor e salvar o ativo.

Depois de repetir as etapas, você terá duas novas instâncias de material: MI_Enemy_01 e MI_Enemy_02.

Em seguida, para atribuir esses materiais ao personagem inimigo, siga estas etapas: 

1. No Blueprint BP_Enemy, no painel Detalhes, vá até a seção Materiais.

2. Clique no menu suspenso para Element 0 e selecione o novo material que você criou: MI_Enemy_01.

3. Para o Elemento 1, mude para o material MI_Enemy_02.  

Como adicionar um inimigo ao nível

Adicione um inimigo ao seu nível para ver como ele está se comportando até o momento. 

No Navegador de Conteúdo, arraste o Blueprint do inimigo para a janela de visualização do nível e coloque-o na frente da pessoa. 

Quando jogar o jogo, você verá o inimigo com uma animação de espera.

Configurar o inimigo quando o jogo começar

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

Para definir a velocidade de movimento do inimigo quando o jogo iniciar, siga estes passos:

1. Na janela do Editor de Blueprint BP_Enemy, vá para a aba EventGraph. Por padrão, existem três eventos: Event BeginPlay, Event ActorBeginOverlap e Event Tick. Selecione o ActorBeginOverlap e exclua-o, pois não é necessário para este tutorial.

2. Usando o painel Componentes, arraste o componente Movimento do Personagem para o Event Graph. Um nó Character Movement será criado. Com o nó deste componente, você pode verificar ou alterar as propriedades do componente diretamente no gráfico.

3. Arraste o pin do nó Character Movement e crie um nó Set Max Walk Speed.

4. Clique com o botão direito no pin verde Velocidade máxima de caminhada do nó Set e selecione Promover a variável. 

   Isso cria uma nova variável no painel Meu Blueprint, na lista Variáveis.  

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

6. Mude a categoria para Setup.

7. Compile o Blueprint e, no painel Detalhes, defina o valor padrão da velocidade máxima como 200.

   Sempre atribua um valor padrão às variáveis editáveis. Se você se esqueceu de alterar o valor no editor de níveis e o valor padrão tiver sido definido como 0, o inimigo não poderá se mover.

8. Conecte Event BeginPlay ao nó Set Max Walk Speed.

   

Em seguida, duas variáveis vão monitorar a vida do inimigo. TotalHP: variável editável na instância, define os PV iniciais do inimigo. HPAtual: monitora a quantidade de vida que o inimigo tem durante o jogo, conforme recebe dano do jogador ou do ambiente.

Para configurar os PV do inimigo, siga estas etapas:

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

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

   

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

4. Renomeie esta variável como TotalHP. Certifique-se de que o tipo dela é 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.

5. Conecte os pins de execução entre os nós Set.

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. 

Para configurar uma variável para o personagem jogável, siga estas etapas:

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

2. Após o nó Set Current HP, conecte um nó Set PlayerRef.   

3. Conecte um nó Get Player Character ao pin de entrada Referência de jogador. Verifique se o valor do Índice de jogador é 0. Este é o índice padrão para o primeiro personagem jogável que surge no nível.

   

Fazer o inimigo perseguir o jogadorT

Em seguida, você criará a lógica para mover o inimigo em direção ao jogador. Você pode fazer isso criando um evento personalizado. Chame eventos personalizados de qualquer lugar no Blueprint para acionar e executar uma lógica.

Para criar um evento personalizado que aciona uma ação de movimento, siga estas etapas:

1. Clique com o botão direito em qualquer lugar no gráfico de evento e insira 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 MoveToPlayer e pesquise o nó IA MoveTo e crie-o. Esse nó é uma ação que os pawns com controle de IA podem usar para se mover para um local específico. Neste caso, você o usará para mover o inimigo até o jogador. 

   Assim como o seu personagem jogável é controlado por um controle do jogador, os personagens PNJ podem ser controlados por um controle de IA. Para visualizar as configurações Auto Possess AI no Blueprint BP_Enemy, selecione o componente-raiz e vá para a categoria Pawn no painel Detalhes.

   

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

4. Arraste o pin Ator-alvo do nó AI MoveTo e crie um nó Get PlayerRef.

5. Defina o raio de aceitação para 10. Esta é a distância, em centímetros, na qual o inimigo considera que chegou ao seu destino. Ela dá mais controle do que Parar em sobreposição.

   

Neste caso, você está usando o nó Self para definir o inimigo como o pawn que deve se mover. Em seguida, defina a pessoa jogadora como o ator-alvo, que é o alvo para onde o pawn se move.

O nó AI MoveTo contém eventos Ao Ter Sucesso e Ao falhar. Eles definem o que acontece se o inimigo alcançar a pessoa jogadora ou se falhar.

Para definir o que acontece depois que o inimigo se move, siga estas etapas:

1. No nó IA MoveTo, 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 da variável WaitAtDestination e garanta que seu tipo será Float.

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

5. No Event Graph, arraste o pin de execução do nó Delay e crie um nó Move To Player. Isso garante que o inimigo continuará perseguindo a pessoa jogadora se esta se afastar. Mas, após um atraso, dá a ela a chance de ganhar alguma distância.

6. No nó IA MoveTo, arraste o pin Ao falhar e crie um nó Delay.

7. Arraste o pin Concluído do nó Delay e crie um nó Move To Player. Deixe a duração como 0,2. Isso garante que o inimigo continuará se movendo até alcançar a pessoa jogadora.

   

8. No grupo de lógica 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.

   

9. Salve e compile o blueprint.

Agora seu gráfico de eventos deve ficar assim:

Como testar o movimento do inimigo

No seu nível, mova o ator inimigo para que ele fique dentro dos limites da NavMesh, ou seja, nas áreas verdes.

Selecione o ator de BP_Enemy na janela de visualização de nível ou no Organizador. No painel Detalhes, você verá as variáveis adicionadas na seção Configuração, no Blueprint. 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.

Jogue o nível novamente e veja como o inimigo se comporta agora. Ele deve caminhar em direção à pessoa jogadora, parar ao chegar, aguardar 5 segundos e tentar caminhar novamente rumo a ela.

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, o inimigo não se moverá. A mesma coisa pode acontecer se os valores forem muito baixos.

Como causar dano ao jogador

Agora que o inimigo pode alcançar a pessoa jogadora, você pode adicionar uma funcionalidade que faça o inimigo causar dano a ela ao colidir. Neste tutorial, você criará um inimigo que se autodestrói ao entrar em contato com a pessoa jogadora. Portanto, você também adicionará uma lógica para remover esse inimigo após ele causar dano a ela.

Para verificar se o inimigo colidiu com a pessoa jogadora, siga estas etapas:

1. No painel Componentes, clique com o botão direito do mouse no componente de cápsula, vá para Adicionar evento e selecione Adicionar OnComponentBeginOverlap. 

   

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

2. Arraste o pin do nó On Component Hit e crie um nó Branch.

3. Conecte o pin Condição ao pin Outro ator do nó On Component Hit, que solicitará a criação de um novo nó.

4. Crie um nó Equal. Arraste a partir do pin Selecionar ativo do nó Equal e adicione uma referência à variável PlayerRef.

   

Agora, essa lógica aciona um evento quando o componente de cápsula do inimigo atingir algo no jogo. O evento verifica se o componente de cápsula atingiu o personagem jogável.

Para causar um ponto de dano à pessoa jogadora e remover o inimigo, siga estas etapas:

1. Na lista Variáveis, crie uma nova variável chamada Eliminação e mude o tipo dela para Booleano. Você usará isso quando o inimigo for derrotado e precisar ser removido do jogo.

2. Para garantir que o dano será causado à pessoa jogadora apenas uma vez, arraste a partir do pin Verdadeiro do nó Branch e crie um nó Do Once.

3. 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 PlayerRef. Este é o ator que deve receber o dano.

4. Clique com o botão direito no pin Dano-base e selecione Promover a variável.

   

5. 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 valor padrão como 25.

6. Arraste a variável Eliminação da lista Variáveis para o Event Graph e selecione Configurar. No nó, clique na caixa de seleção para marcar Eliminação como verdadeiro.

7. Conecte o pin de execução do nó Apply Damage a nó Set Eliminated.

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

9. Arraste o pin de 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 a pessoa jogadora, o dano é aplicado a ela e o inimigo é morto 2 segundos depois.

Agora o inimigo pode correr em direção à pessoa jogadora e, em seguida, causar dano e se autodestruir quando colidir com ela. No entanto, não é considerada a distância ou os obstáculos entre a pessoa jogadora e o inimigo. Desse modo, o inimigo sempre perseguirá a pessoa jogadora, não importa a distância ou a linha de visão.

A lógica finalizada de On Componente Hit, de BP_Enemy, deve ser semelhante a esta:

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

Em seguida, adicione uma distância máxima de detecção para que o inimigo só possa detectar a pessoa jogadora quando estiver perto o suficiente dela. Por fim, implemente as restrições da linha de visão do inimigo para que este não possa ver a pessoa jogadora através das paredes. 

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 (ou projeção de raios) é uma prática comum no desenvolvimento de jogos. Traçados de linha desenham uma linha invisível de um ponto no mundo (como um ator de origem) para verificar o que a linha atinge. Ela costuma ser usada para detectar objetos ou superfícies em tempo de execução, para que você possa acionar a lógica de acordo com o resultado do rastreamento. 

Neste tutorial, você lançará um traçado de linha quando o personagem jogável estiver na linha de visão do personagem inimigo. 

Para obter mais informações sobre traçados de linha, consulte a documentação Traces with Raycasts. 

Para definir uma função que usa um traçado de linha para encontrar a pessoa jogadora, 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, na seção Entradas, clique em Adicionar (+) para criar as seguintes entradas:

   1. Referência do jogador (referência do objeto de pawn)

   2. Posição inicial (vetor)

   3. Distância de detecção máxima (float)

   4. Depuração (booleano) 

      

      Depois de adicionar essas entradas, o nó de entrada da função fnBPLFindPlayer terá pins correspondentes para cada variável.

4. No painel Detalhes da função, na seção Saídas, clique em Adicionar (+) para criar um valor de saída do tipo Booleano chamado Encontrado. 

   

   Depois de adicionar a saída Encontrado, um novo nó Return aparecerá no gráfico com o pin Encontrado.

5. No painel Meu Blueprint, na seção Variáveis locais, clique em Adicionar (+) para criar uma variável local chamada PlayerFound com o tipo Booleano. Garanta que o valor padrão será falso.

   

A referência da pessoa jogadora é fundamental para que a função seja executada corretamente. Portanto, quando a função iniciar, verifique se há uma referência válida do jogador para evitar erros. 

Para verificar uma entrada válida, siga estas etapas:

1. Exclua o fio entre o nó Entry e o nó Return segurando ALT e clicando no fio ou em qualquer um dos pins de execução.

2. Crie e conecte um nó Is Valid ao nó de entrada da função. 

   Crie um nó Is Valid, representado por um ícone de ponto de interrogação (?) próximo à parte inferior da lista de ações do nó.

3. Conecte o pin Referência de jogador do nó de entrada ao pin Objeto de entrada do nó Is Valid.

4. Conecte o pin de execução de Is Not Valid ao nó Return.

5. Conecte uma referência à variável PlayerFound como o valor de Encontrado. Isso encerra a função, retornando PlayerFound=False para o gráfico de evento do inimigo.

   

Se o jogador for válido, a função executará o objeto de traçado de linha e retornará PlayerFound.

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

1. No pin de execução Is Valid, 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. 

   

   Line Trace By Channel detecta objetos em um canal de colisão específico. Para visualizar as configurações do canal de colisão de um Blueprint, selecione o componente de colisão do Blueprint e vá para as propriedades Colisão > Predefinições de colisão no painel Detalhes. A seção Respostas de traçado tem os canais Visibilidade e Câmera.

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

4. Para manter o gráfico organizado, crie um nó Get Player Reference. O ícone f no canto superior direito do nó indica que é uma entrada de função. Você pode adicionar referências a essas entradas como faria com qualquer outra variável.

5. Arraste a partir do pin Referência de jogador até um ponto vazio no gráfico. Abre a lista de ações do nó. Na lista, pesquise e crie um nó Get Actor Location.

6. Conecte o pin Fim ao Valor de retorno do nó Line Trace. Isso encerra o traçado de linha na posição do jogador.

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

   

Agora que você definiu onde o traçado de linha começa e termina, defina o que acontece quando o traçado atinge algo.

Para verificar se um traçado de linha atingiu a pessoa jogadora, siga estes passos:

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

   Você deseja saber se a pessoa jogadora está na linha de visão e dentro de uma certa distância do inimigo. Portanto, você usará o pin Ator de acerto para verificar a pessoa e Início de rastreamento e Fim de rastreamento para medir a distância até o objeto atingido.  

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

   Para referenciar valores de entrada de função, adicione um nó Get semelhante a outras variáveis.

   

4. Crie um nó Distance (Vector). Conecte V1 a Início de traçado e conecte V2 a Fim de traçado. 

   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 a partir 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 (Boolean).

7. Conecte os pins de saída booleanos dos nós Equals (==) e Less (<) aos pinos de entrada do nó AND. 

   

   Com essa lógica, o nó AND retorna verdadeiro se o traçado de linha atingir um ator que seja igual à Referência de jogador 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.

Para usar o resultado do traçado para definir e retornar o valor de PlayerFound, siga estas etapas:

1. Arraste a partir da saída do nó AND e adicione um nó Branch.

2. Conecte o pin de execução para que seja executado após Line Trace By Channel.

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

4. No pin Falso do nó Branch, crie uma variável Set PlayerFound. Mantenha o valor falso.

   

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

   

Como adicionar uma opção de depuração de traçado de linha

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 tornar o tipo de depuração editável no editor de níveis.  

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

1. Arraste a partir do pin Tipo de depuração do desenho do nó Line Trace By Channel e crie um nó Select.

2. Conecte o pin Índice do nó Select a uma referência à entrada Depuração da função. 

   O índice do nó Select é um curinga. Quando você conecta o valor de Depuração do tipo booleano, as opções mudam para False e True.

3. Defina a opção False como Nenhuma. Defina a opção  Por duração como Verdadeira.

4. Na parte inferior do nó Line Trace By Channel, clique no botão de seta para ver mais opções. Mude o Tempo de chamada para 0,1 segundo.

   

5. Salve e compile sua função de Biblioteca de Funções de Blueprint.

Essa lógica usa 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 tipo de desenho de depuração será definido como Nenhum, ou seja, nenhum desenho de depuração será renderizado.

• Quando Depuração estiver definida como verdadeira, o nó Select mudará o tipo de desenho de depuração para Por duração, que renderizará o traçado de linha no tempo de execução por uma certa duração.

A função finalizada fnBPLFindPlayer deve ficar assim:

Como atualizar a lógica de deslocamento até a pessoa jogadora

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, adicione uma lógica ao inimigo que faça com que ele procure e persiga a pessoa jogadora no ato, ou quando o traçado de linha encontrá-la. 

Para fazer o inimigo perseguir a pessoa jogadora após encontrá-la, siga estas etapas:

1. Volte para o Blueprint BP_Enemy. No Event Graph, procure o nó Event Tick fornecido.

2. Arraste o pin de execução do nó Event Tick e crie um nó Branch. 

   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.

4. Neste caso, você quer negar a variável Eliminação. Para isso, arraste o pin de entrada do nó NOT e pesquise Get Eliminated. 

   

   Isso verifica se o inimigo não foi eliminado antes de prosseguir com o pin Verdadeiro do nó Branch.

5. Arraste o pin Verdadeiro do nó Branch e crie um nó FnBPLFindPlayer. Esse nó realizará um traçado de linha para encontrar a pessoa jogadora no mundo e verificará a distância atual entre o inimigo e ela.

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

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

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

   • Distância máxima de detecção: clique com o botão direito no pin e selecione Promover a variável. Clique no ícone do olho para torná-lo editável e altere sua Categoria para Configuração. Compile e defina o valor padrão como 20000 (200 metros). 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 a pessoa jogadora for encontrada pelo traçado de linha, defina a velocidade máxima de movimento do inimigo como o valor desejado, movendo-o em direção a ela. Caso contrário, defina a velocidade como 0 para que o inimigo não possa se mover em direção ao jogador.

Para fazer o inimigo se mover quando a pessoa jogadora for encontrada e parar quando ela não for encontrada, siga estas etapas:

1. No nó FnBPLFindPlayer, clique com o botão direito no pin Encontrado e selecione Promover a variável. Isso conecta automaticamente um nó Set para essa nova variável. 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. Para o pin Velocidade de caminhada do nó Set, conecte uma referência à variável Velocidade máxima.

6. Conecte um nó MoveToPlayer ao nó Set para chamar um evento e fazer o inimigo se mover apenas se tiver encontrado à pessoa jogadora.

   

7. Duplique nó Set Max Walk Speed e o Character Movement. Conecte o pin Falso do nó Branch ao novo nó Set.

8. No segundo nó Set Max Walk Speed, verifique se o valor de velocidade de caminhada é 0. Isso faz com que o inimigo pare de se mover sem cancelar a tarefa IA MoveTo e precisar executar a tarefa novamente.

   

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. Arraste a partir do nó MoveToPlayer e crie um nó Branch.

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

       

Agora, se a pessoa jogadora 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 à pessoa jogadora.

A lista final de variáveis de BP_Enemy deve ficar assim:

A lógica final de Event BeginPlay para o BP_Enemy deve ser semelhante a esta:

A lógica final de MoveToPlayer para o BP_Enemy deve ser semelhante a esta:

A lógica final de Event Tick para o BP_Enemy deve ser semelhante a esta:

Permitir que inimigos recebam dano

Antes de encerrar este Blueprint, você precisa garantir que o inimigo também poderá receber dano. Se continuar trabalhando no jogo após esta série de tutoriais, você pode querer que os inimigos recebam dano de armadilhas ou dar ao público jogador um item equipável capaz de causar dano e eliminar os inimigos.

Para fazer os inimigos receberem dano, siga estas etapas:

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

2. Arraste o pino de execução de Event AnyDamage e crie um nó Set CurrentHP.

3. Para subtrair o dano causado do CurrentHP, arraste o pino da propriedade PV atuais e crie um nó Subtract.

4. Arraste o pin superior do nó Subtract e crie um nó Get Current HP.

5. Conecte o pin inferior do nó Subtract à propriedade Dano do nó evento Event AnyDamage.

   

Quando for causado dano a esse ator, este subtrai o dano da variável CurrentHP e define o valor de CurrentHP como o novo valor.

Em seguida, verifique se CurrentHP é menor ou igual a 0, o que deve eliminar o inimigo.

Para remover o inimigo quando os PV dele chegarem a 0, siga estas etapas: 

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

2. Arraste o pin Condition do nó Branch e crie um nó Less Equal (<=).

3. Conecte o pino de saída do nó Set Current HP ao pino de entrada superior do nó Less Equal. Verifique se o pin inferior está definido como 0.

4. Arraste o pin Verdadeiro do nó Branch e crie um nó Do Once.

5. Arraste seu pin Concluído e crie um nó Set Eliminated. 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. Arraste o pin Concluído do nó Delay e crie um nó Destroy Actor com a propriedade Alvo definida como Próprio.

   

8. Salve e compile o blueprint.

A lógica finalizada de Event AnyDamage para BP_Enemy deve ser semelhante a esta:

Teste o personagem inimigo finalizado

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 a pessoa jogadora. 

Tente com um obstáculo. Saia do modo de jogo e adicione uma parede ou cubo de bloqueio no meio da zona da NavMesh pressionando o botão Criar na barra de ferramentas principal e selecionando Formatos > Cubo. Esse obstáculo incide sobre a NavMesh.

Se a pessoa jogadora começar atrás do cubo, o inimigo não poderá persegui-la, pois o traçado de linha está bloqueado por ele, fazendo com que o inimigo não consiga encontrar a pessoa. Se a pessoa jogadora andar ao redor do cubo e o inimigo tiver visão direta dela, ele começa a persegui-la. Quando o inimigo iniciar a ação IA MoveTo, esconder-se atrás de um obstáculo não interromperá a perseguição. 

Se você quiser que um inimigo veja a pessoa jogadora através de um obstáculo, selecione o objeto de nível e vá até Colisão > Predefinições de colisão no painel Detalhes. Altere a predefinição para Personalizada e ative Ignorar no canal Câmera . Para fazer um objeto bloquear o traçado de linha, altere a configuração para Padrão.

Como colocar posições de inimigos no seu projeto

Para o nosso nível de amostra, colocamos vários inimigos no Corredor 3 e na Sala 3. O primeiro inimigo está sozinho no Corredor 3. Isso foi feito para dar à pessoa jogadora um primeiro encontro simples e ajudá-la a se familiarizar com as habilidades e o comportamento dele. Depois de encontrar o único inimigo no corredor, colocamos dois personagens inimigos adicionais na Sala 3 para apresentar um desafio a mais à pessoa jogadora. 

Você pode variar a quantidade e os tipos de inimigo 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 equilibrada, com a qual a pessoa pode se acostumar com o tempo. Criar um encontro difícil com o inimigo, depois de permitir que a pessoa aprenda a explorar e derrotar os inimigos, fornece um desafio que pode parecer recompensador para ela.

Próxima

No próximo módulo, você aprenderá como adicionar uma mecânica de disparada ao conjunto de movimentos do público jogador. Isso ajuda a pessoa a se mover por lugares familiares no nível e também dá a ela 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.