‫Olá e bem-vindo.
‫Nesta palestra, vamos tornar um inimigo mais uma ameaça implementando um nó de disparo em C++.
‫Vamos mergulhar e ver como fazê-lo.
‫Portanto, uma funcionalidade que claramente está faltando em nossa árvore de comportamento é a capacidade de atirar.
‫O que eu gostaria de fazer é ir até o local do jogador e depois atirar.
‫Mas queremos mudar um pouco primeiro como fazemos o movimento.
‫Há algumas coisas que eu quero ajustar, então se eu selecionar o movimento para o Node, uma coisa que eu
‫quero mudar é o raio.
‫Eu não quero que o inimigo venha até mim, então se eu mudar o raio aceitável, ele vai
‫parar de se mover a cinco metros de mim.
‫Então vai parar.
‫Dê-me uma boa distância de cinco metros.
‫Ele vem até mim, eles vão e ele para e olha.
‫Agora, a outra coisa que eu quero fazer é aqui na seção de quadro-negro, você pode ver que há um valor
‫de quadro-negro de observação.
‫Se não tivermos isso verificado, vamos ver o que acontece enquanto eu me movo.
‫Ele basicamente e isso era um pouco mais óbvio quando tínhamos um raio aceitável menor.
‫Então vamos apenas colocar isso aí em cinco quatro agora.
‫E se eu apertar o play, você pode ver isso enquanto eu me movo.
‫Ele vai para a minha última localização e só então quando chega lá, ele vem uma atualização.
‫Não é isso que queremos.
‫O que queremos é que esteja constantemente vindo em nossa direção.
‫E se você verificar o valor do quadro-negro observado, então essencialmente o que ele está dizendo é que toda
‫vez que o local do jogo muda, vamos atualizar para onde estamos nos movendo.
‫Então, se eu for em frente e apertar o play e mover, você pode ver que ele está continuamente me seguindo e atualizando
‫seu caminho.
‫É exatamente isso que queremos.
‫Então agora podemos alterar nosso raio de aceitação para 500 e isso se torna menos óbvio.
‫Mas ainda é bom que tenhamos nosso valor de quadro-negro de observação lá.
‫E então o comportamento que queremos é que, uma vez que ele chegue perto de nós, ele pare e
‫atire em nós.
‫Para isso precisamos de um novo tipo de tarefas.
‫Vamos criar uma nova tarefa C++ aqui?
‫Vai adicionar uma nova e nova classe C++.
‫Então vamos mostrar todas as classes e procurar a tarefa beta.
‫Agora, qual queremos?
‫O nó da tarefa beta ou a base do quadro-negro da tarefa beta?
‫Bem, na verdade não precisamos usar uma chave porque vamos apenas tentar atirar.
‫Isso é tudo que vamos fazer.
‫Vamos puxar o gatilho da nossa arma.
‫Todo o direcionamento será feito em outro lugar em nossa árvore de comportamento.
‫Então, vamos abrir o nó de tarefa beta, a classe básica aqui, e vamos chamar isso de Beaty Task.
‫Sublinhado.
‫Atirar.
‫Vamos em frente e criar essa classe.
‫Então acabamos com algo assim.
‫Então, queremos fazer a mesma configuração.
‫Então, um pequeno desafio para nós fazermos o mesmo tipo de configuração que fizemos para o nosso quadro-negro.
‫Limpar valor do quadro-negro.
‫Queremos ter um nome.
‫Queremos ter uma nota de tarefa de execução, um vídeo de pausa e tentar isso.
‫OK.
‫Bem vindo de volta.
‫Então essa foi uma mini tarefa.
‫Vou apenas copiar as assinaturas do meu quadro-negro para filmar, incluindo as
‫seções públicas e protegidas.
‫Vou mudar o nome do nosso construtor.
‫Vou seguir em frente e implementar um construtor.
‫E o que é que precisávamos fazer?
‫Precisamos definir o nome do nó igual a atirar.
‫É assim que vamos chamá-lo.
‫Então, de volta ao cabeçalho para a tarefa de disparo e vamos tentar implementar a tarefa de execução agora.
‫E só precisamos chamar para super algum tipo de cópia do nosso arquivo Clear Blackboard Values CP
‫e então estamos prontos para começar a implementar.
‫Então a primeira coisa que vamos precisar fazer aqui, vamos ter um pouco mais de
‫espaço é que vamos precisar pegar nosso peão.
‫Por que precisamos pegar nosso peão?
‫Bem, vamos dar uma olhada no personagem atirador, que é um peão.
‫Lembre-se do personagem atirador?
‫Dot H tem um método de disparo.
‫Isso é o que queremos chamar essencialmente o mesmo que o jogador está fazendo.
‫Ele está segurando o botão do gatilho e isso está chamando esse método de tiro.
‫Queremos que o cara seja capaz de fazer o mesmo.
‫Quando você tiver a tarefa de atirar, ela manterá pressionado o botão de disparo ou pressionará repetidamente esse botão de disparo para
‫que a tarefa de execução seja o lugar certo para fazer isso.
‫Provavelmente vamos devolver o que aqui, porque lembre-se, esta ação é apenas um tiro.
‫Não é tiro contínuo.
‫O que nós vamos fazer?
‫Vamos retornar o sucesso do resultado da nota vazia.
‫Se todos tivéssemos sucesso.
‫Se tivemos sucesso porque não precisamos chamar o tick continuamente.
‫Não precisamos que essa tarefa seja executada por mais de um único quadro.
‫E a outra coisa que precisamos fazer é pegar, como eu disse, aquela classe de peões.
‫Bem, o que vou fazer é mostrar como você pode pegar o controlador aéreo.
‫E do controlador aéreo, sabemos que podemos chamar get peão para obter o peão que foi controlado.
‫E sabemos que podemos lançar esse peão controlado para nossa implementação de personagem de tiro.
‫Então, como podemos obter o controlador de ar a partir disso?
‫Bem, temos nosso componente de árvore de comportamento, que sabemos que está em um controlador aéreo.
‫Então talvez isso tenha algo que possamos usar se formos ao componente da árvore de comportamento e dermos uma
‫olhada aqui para quaisquer métodos que possam ser úteis.
‫Há muito aqui, mas se procurarmos pelo controlador, não veremos nada, mas talvez em algum lugar em uma de suas
‫classes base, porque a classe pai para o componente da árvore de comportamento de uso é o componente you
‫brain.
‫Seguimos até aquele para procurar o controlador aqui.
‫Você pode ver que há uma propriedade para isso.
‫Existe um getter?
‫Sim, é chamado de obter proprietário do ar e isso deve retornar se passarmos o mouse sobre ele e eu controlar um ponteiro.
‫Então você deve ser capaz de usar isso para pegar o peão, lançá-lo para um personagem de tiro e
‫então chamar o método de tiro.
‫Então esse será o seu desafio.
‫A chamada.
‫O método de atirar, torná-lo público, pegar o peão, lançar a chamada do peão, atirar e depois testá-lo em
‫sua árvore de comportamento.
‫Pause o vídeo e pronto.
‫OK.
‫Bem vindo de volta.
‫Então, primeiro de tudo, o primeiro passo é tornar este método shoot público porque ele precisa
‫ser chamado de fora desta classe.
‫Então vamos colocá-lo apenas para causar danos, vamos atirar, dar um pouco de espaço para ele, um pouco de
‫espaço para respirar.
‫Eu gosto de espaço em branco me ajuda a ver, me ajuda a pensar.
‫Então vamos para a sessão de fotos de Beatty.
‫Vamos, antes de mais nada, verificar se o controlador I não é nulo.
‫Caso contrário, não podemos usar o operador de seta nele.
‫Apenas uma boa prática geral para fazer essas verificações de unhas.
‫Portanto, se esse proprietário não for igual, ele será igual ao ponteiro nulo.
‫Vamos querer voltar cedo com uma falha.
‫Portanto, esta tarefa falhará se não tivermos um controlador aéreo.
‫Isso é bem direto.
‫Então eu posso fazer um retorno de resultados de nós vazios.
‫Cólon.
‫Colon falhou assim.
‫E então vamos fazer o proprietário, o proprietário do componente, vamos entrar.
‫Na verdade, talvez precisemos incluir um cabeçalho de arquivo aqui.
‫Então, vamos fazer uma inclusão de hash e será a estrutura do jogo e o controlador e se eu achar, sim, qualquer controlador deve servir, mas acho
‫que precisamos do controlador aéreo porque esse é o tipo de pontos que estamos voltando e então vamos fazer uma
‫flecha e vamos fazer um get -- aqui reclamando de algo na minha cabeça, um
‫arquivo, talvez eu não tenha entendido algo certo.
‫Então barra para frente parece que eu entendi errado.
‫Na verdade, não está na estrutura do jogo.
‫Você só tem um controlador para incluir isso.
‫Ensina-me por ser tão blasé sobre isso.
‫Então vamos lá.
‫Agora podemos obter o -- do.
‫E como eu disse, também precisamos fazer um elenco.
‫Então, vamos fazer um elenco para o tipo que precisaremos lançar para o A do personagem de tiro.
‫Então isso está em sua forma completa, uma filmagem de um personagem, uma filmagem, um personagem.
‫E nós vamos precisar verificar o resultado disso também.
‫Mas precisamos incluir o personagem de tiros de cinzas.
‫Então hash inclua no topo o personagem do atirador que achou assim.
‫E nós vamos armazenar isso em um tipo de ponteiro, os tiros de personagem ainda serão um personagem.
‫Então eu vou chamá-lo, vamos armazená-lo lá.
‫E basicamente, precisamos ter certeza de que nem o peão get retornou porque o peão get pode retornar nulo se
‫o olho não estiver controlando um peão no momento.
‫Ou esse lançamento pode retornar null se o tipo não for um personagem de oito atiradores dele controlando um tipo diferente
‫de peão.
‫Felizmente, esses dois funcionam muito bem juntos, então se você tentar lançar um ponteiro nulo, o resultado é apenas um ponteiro
‫nulo, e é por isso que podemos fazer isso.
‫Essas verificações todas em uma linha.
‫Então podemos fazer um caractere if.
‫É igual a ponteiro nulo.
‫Então queremos falhar novamente.
‫Então volte.
‫Resultados do nó IBT.
‫Cólon.
‫Colon falhou assim.
‫E finalmente, depois de todas essas verificações, sabemos que temos um personagem de tiro.
‫Devemos ser capazes de chamar, atirar.
‫Então, o personagem dispara e dispara assim.
‫Então, isso finalmente nos permitirá atirar.
‫Vamos para a nossa árvore de comportamento.
‫E aqui vamos querer puxar para baixo para colocar um novo nó e procurar a nova tarefa de tiro que
‫temos aqui.
‫E não tenho certeza se compilei, então vou me certificar de que tudo seja compilado novamente.
‫E uma vez feito isso, podemos ir até lá e apertar o play e ver se esse cara aparece e atira, ok?
‫Sim ele faz.
‫Infelizmente, ele está atirando repetidamente e atirando no próprio pé.
‫Então, algo não está bem escrito ali.
‫Então tem duas coisas dando errado.
‫Para começar, ele conseguiu se matar com dois tiros, e também parece que ele está filmando cada quadro,
‫o que faria sentido porque estamos conseguindo ver o jogador, nos movemos para ele e
‫então atirar é a última ação temos aqui, que vamos executar repetidamente.
‫Então, o que queremos fazer é transformar isso em uma sequência.
‫Então, vou arrastar um nó aqui, vamos fazer um nó de sequência, e o que vamos
‫fazer é filmar, esperar, filmar, esperar e repetir isso indefinidamente.
‫Então atire primeiro, espere um pouco.
‫Então talvez esperemos, não sei, por 1/2 entre as tomadas e então vamos querer repetir isso, o que podemos
‫fazer com um decorador.
‫Então, se eu clicar com o botão direito do mouse em adicionar decorador e procurar o decorador de loop, você poderá ver quantas vezes deseja que ele
‫faça um loop.
‫Diz três vezes.
‫Não queremos três vezes.
‫Queremos que ele faça um loop infinito até que precisemos nos mover ou perdermos o plano de vista.
‫Precisamos ir investigar.
‫Então vamos em frente e apertar play e ver se isso funciona.
‫Vem até mim.
‫Atira, atira, atira.
‫Mas ele não está realmente me batendo.
‫Você pode ver que seus tiros estão realmente pousando nele mesmo.
‫E vamos lidar com esse bug em uma próxima palestra.
‫Vê isso?