‫Ei.
‫Bem vindo de volta.
‫Agora nos configuramos com uma função de retorno de chamada vinculada ao delegado para receber qualquer dano.
‫E o último passo é realmente gerar esse evento de dano.
‫E queremos fazer isso quando nosso projétil atingir alguma coisa.
‫Uma vez que transmitimos para este delegado, podemos aplicar danos à coisa que atingimos.
‫E vamos transmitir este evento usando dano aplicado, que pertence à classe de estática do
‫jogo.
‫Então, vamos dar uma olhada na função de dano aplicado.
‫Agora aqui está a documentação para dano aplicado que diz que fere o ator especificado com dano genérico.
‫Portanto, esta é uma função genérica para aplicar danos.
‫E o que fazemos em resposta à transmissão para este delegado depende de nós.
‫Agora aqui vemos que precisamos incluir a estática do jogo e na sintaxe vemos vários parâmetros de entrada.
‫Agora nós realmente temos alguma descrição dos parâmetros.
‫Se continuarmos rolando para baixo, vemos que o ator danificado está bem, o ator que
‫sofrerá dano base é o dano base para aplicar documentação realmente descritiva aqui.
‫Obrigado.
‫O instigador do evento épico é o controlador responsável por causar esse dano.
‫E diz, por exemplo, o jogador que disparou a arma.
‫Quando diz jogador, está se referindo a esse controlador.
‫Então temos o causador do dano, que é o ator que realmente causou o dano.
‫Diz a granada que explodiu.
‫No nosso caso, será o projétil que explodiu.
‫E finalmente, temos a classe do tipo de dano, que é uma classe que descreve o dano que foi feito.
‫Agora, voltando à seção de sintaxe, podemos ver os tipos dessas entradas e vemos que a classe do tipo de
‫dano é uma subclasse de e vimos antes que a subclasse TW de satisfará um parâmetro de entrada da classe
‫do tipo U.
‫Bem, quando chamamos aplicar dano, podemos passar uma classe U representando o tipo de dano que gostaríamos de
‫usar.
‫Então, falaremos sobre como vamos satisfazer esse parâmetro de entrada em um momento.
‫Portanto, a função de estática do jogo de matiz, o dano aplicado, exigirá alguns parâmetros de entrada.
‫Então, vamos criar uma estratégia sobre como vamos passar os valores apropriados quando chamamos essa
‫função, vimos que primeiro precisamos do ator danificado.
‫Bem, vamos voltar ao CP do projétil, onde gostaríamos de chamar o dano aplicado.
‫Gostaríamos de fazer isso aqui no acerto e não precisamos mais desses logs.
‫Então, vou simplesmente removê-los e observar que nosso retorno de chamada on hit recebe algumas entradas passadas uma vez
‫que é chamado.
‫Quando o delegado de hit do componente on é transmitido, veremos que temos outro ator.
‫Então temos acesso ao ator que foi atingido pelo projétil e este é o ator que gostaríamos
‫de danificar.
‫Então isso cuida do primeiro parâmetro de entrada.
‫Vai ser aquele outro ator.
‫Em seguida, precisamos da quantidade de dano, o que significa que nosso projétil deve ter uma variável de
‫dano para sabermos quanto dano aplicar.
‫Então, por que não entramos no FX do projétil e adicionamos uma variável de dano e isso pode ser um float.
‫Então, podemos simplesmente chamar esse dano e inicializá-lo com um valor, digamos algo como 50 F
‫e, como isso é algo que provavelmente gostaríamos de experimentar, podemos dar a isso uma propriedade
‫U para expô-lo e editá-lo qualquer lugar.
‫Então agora temos uma quantidade de dano para passar quando chamamos de receber dano.
‫Agora o próximo parâmetro é o instigator e vimos que este é do tipo A controller.
‫Então, como vamos obter o controlador?
‫Bem, vimos que podemos obter o proprietário de um componente específico com a função get owner.
‫E isso retorna o ator que possui um determinado componente, esses projéteis estão sendo gerados dinamicamente.
‫Portanto, precisamos ter certeza de que, se vamos chamar get owner, que o owner está definido agora, estamos
‫gerando isso do peão base.
‫Então, se formos para o peão base.
‫CP Aqui está a linha onde estamos gerando o ator, mas Spawn Actor também retorna um ponteiro para o ator que foi
‫gerado para que possamos armazenar isso em uma variável local.
‫Por exemplo, poderíamos dizer auto projétil e atribuir o valor retornado do ator de desova.
‫Agora, se você não estiver familiarizado com auto, ele permite que o compilador descubra o tipo a ser atribuído a
‫essa nova variável.
‫Se você passar o mouse sobre ele, verá que ele tem o ponteiro de projétil do tipo A porque é
‫isso que estamos assinando na função de ator de desova.
‫Então isso é o mesmo que se tivéssemos colocado um ponteiro de projétil bem aqui e agora podemos acessar
‫esse projétil recém-gerado.
‫E a razão pela qual queremos fazer isso é que gostaríamos de definir seu proprietário.
‫Gostaríamos de ter certeza de que seu dono está definido para o peão que o gerou.
‫Então podemos dizer projétil.
‫E há uma função para isso chamada proprietário do conjunto.
‫O dono do set pega um ator e vamos passar isso para que sempre que um de nossos peões gerar um
‫projétil, ele definirá o dono desse projétil.
‫Dessa forma, se alguma vez chamarmos get owner mais adiante, obteremos a instância da
‫classe que possui esse projétil.
‫Então, aqui no DHCP do projétil, temos nossa chamada de função get owner e podemos armazenar isso em uma variável
‫local.
‫Vou seguir em frente e usar auto novamente e chamar isso de meu proprietário e configurá-lo para o resultado retornado por
‫get proprietário.
‫Então agora temos um ponteiro de ator local que armazena o valor do proprietário.
‫Agora podemos acessar o controlador instigador deste ator.
‫Agora, antes de fazermos isso, é uma boa ideia verificar se meu proprietário não é nulo.
‫Então eu vou dizer se meu dono é null igual a ponteiro nulo, então eu vou simplesmente retornar.
‫Agora, se você está se o corpo tem uma única instrução como esta, você pode colocá-la na mesma linha
‫sem as chaves caso você não saiba.
‫E ponteiro nulo é uma palavra-chave em C++ que permite verificar se um ponteiro é um ponteiro nulo.
‫Portanto, se meu proprietário for nulo, retornaremos da função antecipadamente e não faremos mais nada.
‫Agora, como eu estava dizendo, podemos obter o controlador instigador do meu proprietário e
‫é isso que o uso da função chamada get instigator controller.
‫E se passarmos o mouse sobre isso, veremos que ele retorna um ponteiro de controlador A.
‫Vou simplesmente usar auto e armazenar isso em uma variável local que chamarei de instigador do meu proprietário.
‫Então agora sabemos o que passar como instigador.
‫A próxima entrada é o causador do dano e este é o ator que causa o dano ao projétil.
‫Isso vai ser simplesmente isso.
‫E isso deixa o último parâmetro de entrada, que é um tipo de dano.
‫E vimos que é uma subclasse do que significa que precisamos da classe de uso adequada para passar.
‫N Agora aqui está a documentação do mecanismo irreal para seu tipo de dano.
‫Ele diz que um tipo de dano destina-se a definir e descrever uma forma específica de dano
‫e fornecer um caminho para personalizar respostas a danos de várias fontes.
‫Agora, não vamos personalizar nosso dano.
‫Só precisamos satisfazer o parâmetro de entrada, o que significa que precisamos de um valor de classe U que represente essa
‫classe de tipo de dano.
‫Agora, em C++, se quisermos obter a classe YOU de qualquer classe em particular, como seu tipo de dano, podemos
‫chamar uma função chamada classe estática.
‫Isso é herdado da classe de objeto you.
‫Agora é claro que estamos usando seu tipo de dano aqui, então vamos precisar desse cabeçalho.
‫Então da documentação eu vou copiar a linha de inclusão e vou colar aqui no topo do CP
‫do projétil E agora você verá que essa função de classe estática retorna um ponteiro de classe U e essa nova classe
‫representará o novo tipo de dano classe C++.
‫Agora, como não estamos criando um blueprint baseado em seu tipo de dano e configurando alguns dados extras,
‫não precisamos de uma subclasse de variável.
‫Então, neste caso, podemos usar a classe estática e isso retornará uma classe U que representa esse tipo.
‫E podemos armazenar isso em uma variável, se quisermos, e chamarei essa classe de tipo de dano.
‫E é isso que podemos passar como parâmetro final para aplicar dano.
‫Então agora temos todas as informações que precisamos passar para a função de aplicar dano.
‫Mas antes de fazermos isso, gostaria de fazer algumas verificações para ter certeza de que é apropriado chamarmos
‫essa função.
‫Então eu vou fazer uma declaração if aqui.
‫Primeiro, quero ter certeza de que outro ator não é nulo.
‫Então eu vou colocar outro ator aqui.
‫Vou colocar um e aqui para verificar se o outro ator não é igual a esse ator.
‫Não queremos causar danos a nós mesmos se formos o projétil agora vou colocar outra ponta
‫e garantir que outro ator não seja igual ao meu dono.
‫Não seria bom se o projétil estivesse causando danos ao seu dono.
‫E agora, se entrarmos nessa instrução if, saberemos que é apropriado chamar aplicar dano para
‫que possamos fazê-lo.
‫E esse será o seu desafio.
‫Portanto, em nossa nova instrução if na função on hit, chame a função de aplicação de dano de estática de jogo.
‫Isso significa que você precisará incluir o cabeçalho correto para as estatísticas de jogo e saberá quais parâmetros
‫de entrada passar.
‫Então, pause o vídeo e adicione a chamada de função para aplicar dano na função on hit agora.
‫OK.
‫Então, estou aqui no CP de projéteis e vou incluir o arquivo de cabeçalho para estatísticas de jogo e podemos
‫ver na página Applied Damage Documentation que a inclusão é kismet slash estática de jogo.
‫Então, vou colar isso lá e agora estou pronto para chamar aplicar dano.
‫Então, vou chamá-lo de estática de jogo aplicar dano.
‫Agora, assim que eu digito os parênteses de abertura, recebo o pop-up me lembrando dos parâmetros de entrada de que
‫preciso.
‫E o primeiro é o ator danificado e esse será outro ator.
‫Então, vamos digitar outro ator em seguida.
‫Precisamos da quantidade de dano e adicionamos essa flutuação de dano no FX do projétil, que definimos como 50.
‫Então eu vou passar o dano final em seguida.
‫Precisamos do instigador e temos o instigador do meu dono.
‫Então vou passar no meu dono instigador.
‫Em seguida é o causador do dano.
‫E, claro, o próprio projétil é o causador do dano.
‫Então vamos passar nisso.
‫E, finalmente, precisamos da subclasse de seu tipo de dano que sabemos que um ponteiro de classe U satisfará isso e é por
‫isso que temos nossa classe de tipo de dano.
‫Então vamos passar na classe de tipo de dano.
‫E com isso estamos chamando de aplicar dano.
‫Então, quando chamamos isso, vamos gerar o evento de dano e o On Take any Damage Delegado será transmitido em resposta
‫a isso, o que significa que em nosso componente de saúde, o dano recebido será chamado.
‫Então, nós só precisamos fazer algo aqui em danos sofridos.
‫Bem, faria sentido tomar esse dano e subtrair esse valor da saúde.
‫Antes de fazermos isso, porém, gostaria de ter certeza de que o dano não é menor ou igual a zero.
‫F Faz sentido fazer essas verificações antes de documentar o dano, apenas para ter certeza de que não aplicamos um
‫valor que não faz sentido, como zero ou um valor negativo.
‫Então, se for esse o caso, simplesmente retornaremos.
‫E claro, se você quiser ser esperto e fazer o que eu fiz no projétil no CP, podemos colocar o retorno
‫ali mesmo.
‫Agora, se passarmos dessa linha, o dano é um valor positivo para que possamos pegar a saúde e usar
‫menos igual ao dano.
‫E só para ter certeza de que isso está funcionando, por que não colocamos um log euy aqui?
‫Então log de log do Yui, texto de aviso temporário e podemos simplesmente imprimir o valor da saúde com porcentagem F e saúde
‫e com isso podemos compilar.
‫Agora, com uma compilação bem-sucedida, voltaremos ao editor e, com nosso log de saída aberto, vamos clicar
‫em play.
‫Agora vamos ver se podemos ser atingidos por um projétil.
‫E lá vamos nós.
‫Nossa saúde está agora em 50 e se formos atingidos novamente, teremos alguns eventos de acerto porque
‫estávamos acertando o projétil muitas vezes muito rapidamente.
‫Mas vemos que nossa saúde está documentando adequadamente.
‫Portanto, precisamos garantir que implementamos o comportamento correto após a morte quando a saúde chegar a zero.
‫Mas também precisamos garantir que esse evento de hit não seja enviado várias vezes como spam.
‫Agora sabemos que o projétil deve ser destruído ao atingir algo, então a melhor maneira de evitar spam
‫no evento de acerto é destruir o projétil.
‫Então essa é a última coisa que faremos neste vídeo.
‫Então, de volta ao projétil logo após o dano aplicado, o que podemos fazer é fazer com que o projétil se destrua e isso
‫não poderia ser mais fácil.
‫Simplesmente chamamos a função destroy.
‫Então, com mais uma compilação aqui no editor, podemos ir em frente e ser atingido por um projétil e olhar para
‫isso.
‫O projétil se foi.
‫Então ele faz o seu dano e depois desaparece.
‫E é claro que podemos testar acertar as torres também, explodindo-as com projéteis e certificando-nos de que
‫esses eventos de acerto sejam acionados.
‫E como você pode ver, eu posso enviar spam com um monte de projéteis e veremos que
‫o valor de saúde para esta pobre torre aqui está ficando muito, muito negativo.
‫Então, em resumo, chamamos a função de aplicar dano e isso resultou em uma transmissão para o delegado de
‫receber qualquer dano.
‫Documentamos a saúde no componente de saúde e destruímos o projétil.
‫Então, agora cuidamos dos danos.
‫Nós ainda não cuidamos da morte.
‫Então, essa será uma das próximas coisas que abordaremos em um vídeo futuro.
‫Vejo você em breve.