‫OK.
‫Portanto, nosso objetivo para este vídeo é implementar a morte para nossos Pons.
‫Então, se eu for atingido algumas vezes da nossa torre, você verá que eu desapareci porque meu tanque
‫morreu.
‫E se eu for habilidoso o suficiente, se eu puder ir em frente e destruir um deles, você verá que ele
‫também desaparece.
‫Então, vamos implementar a morte para esses peões neste vídeo.
‫Olá e bem-vindo de volta.
‫Agora já estamos aplicando dano aos peões quando são atingidos por projéteis.
‫Agora precisamos descobrir como vamos lidar com a morte.
‫Isso significa que precisaremos de algum tipo de função para lidar com a destruição de um determinado ator.
‫Então vamos criar uma função de destruição de handle.
‫Também precisamos de um ator morrer para funcionar, o que pode permitir que o modo de jogo lide com o que acontece quando
‫um ator em nosso mundo morre e vamos chamar esse ator morreu de função quando o valor de saúde chegar
‫a zero para um peão específico.
‫Então, vamos falar um pouco sobre um roteiro de como vamos implementar esse sistema.
‫Sabemos que temos um projétil e ele está chamando aplicar dano e isso resulta na função de receber
‫dano respondendo a essa transmissão de delegado no componente de saúde.
‫Então, precisamos descobrir o que fazer a partir daí.
‫Bem, nosso modo de jogo pode ter uma função para lidar quando um ator morre.
‫Assim, no dano recebido, podemos verificar se a saúde chega a zero.
‫E nesse ponto podemos chamar a função ator morreu no modo de jogo e a partir daí nosso peão pode lidar
‫com sua destruição.
‫Então, em última análise, caberá ao modo de jogo chamar a função de destruição do identificador no ator que
‫morreu.
‫Portanto, temos um plano de jogo, então vamos descrever as etapas a serem seguidas para implementar isso.
‫Primeiro, vamos criar a função handle de destruição e vamos colocá-la na classe base do peão
‫para lidar com a funcionalidade que deve acontecer quando qualquer um de nossos peões morrer.
‫E também implementaremos isso nas classes tanque e torre, já que cada uma terá sua própria funcionalidade
‫única quando morrerem, então criaremos uma função de ator morto e colocaremos isso na classe de modo de
‫jogo para que possamos chame a destruição do handle de lá.
‫Depois disso, vamos chamar a destruição do handle na função ator morreu no modo de jogo e então podemos
‫chamar o ator morreu do componente de saúde quando a saúde chegar a zero.
‫Então vamos começar com o nosso primeiro passo criando a função de destruição do handle.
‫Então, estou aqui na Base Pond H e gostaria de adicionar essa função de destruição de alça.
‫Agora estou planejando chamar isso do modo de jogo, o que significa que precisará ser uma função
‫pública para que eu possa colocar essa função aqui na seção pública.
‫Vai ser nulo e vou chamá-lo de lidar com a destruição.
‫Agora, ele não precisa receber nenhum parâmetro de entrada.
‫Ele simplesmente vai lidar com a destruição deste peão em particular.
‫Então, vamos implementar essa função no arquivo CP do peão base e vou colocá-la aqui embaixo
‫do construtor.
‫Então eu tenho o handle da destruição e vou colocar o nome da classe do peão de base logo antes do nome da
‫função aqui.
‫Agora, isso vai acontecer quando qualquer um dos peões baseados no peão base morrer.
‫Então, vou colocar um a fazer aqui que diz o que vamos fazer na função de destruição de alças.
‫Eu gostaria de lidar com todos os efeitos visuais e sonoros aqui que têm a ver com a morte do peão.
‫Então, vou apenas dizer efeitos sonoros de barra visual e vamos deixar por isso mesmo e vamos
‫nos certificar de implementar isso quando chegarmos aos efeitos especiais e sons nesta seção do
‫curso.
‫Agora temos destruição de alças aqui, mas eu gostaria de colocar também uma função de destruição de alças
‫nas classes tanque e torre para lidar com o que acontece quando esses peões morrem.
‫E a implementação mais simples de destruição talvez seja para nossa torre.
‫Então vamos entrar na Torre H e adicionaremos uma função pública aqui chamada manipular destruição.
‫Então, vou dizer void handle destroy e vou implementar isso e a torre CP logo abaixo da função
‫tick.
‫Então, aqui está o carrapato, aqui está o identificador de destruição e eu vou prefixar o nome da função com uma torre
‫assim.
‫Agora, na função de destruição de alças para a torre, eu gostaria de chamar a super versão para que a destruição
‫de alças no peão base seja chamada e tenhamos esses efeitos visuais e sonoros quando uma torre morrer.
‫Então, eu vou dizer super lidar com destruição apenas para ter certeza de que isso seja chamado.
‫E depois disso, vou simplesmente destruir a torre.
‫Agora vimos como isso funciona.
‫Nós simplesmente chamamos a função destroy, e isso vai lidar com a destruição da torre.
‫Então eu posso salvar isso e fechar os arquivos de torre e CP e agora posso colocar uma função de destruição
‫de alça na classe tanque.
‫Então eu vou para o tanque e declarar uma função pública aqui sob a função tick chamada de destruição
‫de controle.
‫E eu vou para o Tank CP e implemento isso logo abaixo do tic aqui, não esquecendo de prefixar o
‫nome da função com um tanque.
‫Agora, assim como na classe da torre, gostaríamos de chamar a destruição do super handle.
‫E assim conseguiremos esses efeitos visuais e sonoros.
‫Agora para o tanque, vamos fazer algo um pouco diferente.
‫Eu gostaria de esconder o tanque em vez de destruí-lo.
‫E então podemos desabilitar sua funcionalidade TIC para que ela ainda exista no mundo e ainda a tenhamos.
‫Então ainda temos essa visão da câmera.
‫Só que não poderemos vê-lo ou movê-lo.
‫Então para esconder o tanque podemos chamar uma função chamada set ator hidden in game e isso vai levar um booleano.
‫E se passarmos de verdade, esconderemos efetivamente o tanque.
‫Agora eu também gostaria de desabilitar o ticking e há uma função para isso também.
‫É chamado de set ator tic ativado.
‫E para isso vou passar em false, que vai desabilitar o ticking para o tanque.
‫Então, isso cuida da nossa função de destruição de alças.
‫Portanto, temos nossa função de destruição de alças.
‫Nosso próximo passo é criar uma função de ator morto no modo de jogo.
‫Então vamos implementar isso.
‫Então, estou aqui no modo de jogo de tanques de sintonia e aqui posso criar a função ator morreu agora pretendo chamar o ator
‫morreu da classe do componente de saúde, o que significa que isso também precisa ser uma função pública.
‫Então, vou adicionar uma seção pública e criar a função ator morreu.
‫Agora isso será anulado e eu vou chamá-lo de ator morreu.
‫E isso pode simplesmente levar um ponteiro de ator chamado Dead Actor e agora podemos implementar o ator morreu no modo de jogo
‫de tanques de sintonia.
‫CP Então, vou colocá-lo aqui e prefixar o nome com um modo de jogo de tanques de sintonia e agora temos uma função
‫de ator morto.
‫Agora eu gostaria de verificar se o ator morto é o tanque, o que significa que vou precisar de uma
‫variável para o tanque.
‫Então, de volta ao modo de jogo de tanques de sintonia.
‫Eu vou fazer uma seção privada e vou adicionar uma variável de tanque que vou declarar para
‫frente.
‫E é um ponteiro de tanque do tipo A e eu vou simplesmente chamar este tanque e vou precisar inicializá-lo com
‫o endereço do tanque do tanque, e posso fazer isso e começar a jogar.
‫Agora vimos que começar a jogar é uma função protegida e vamos mantê-la protegida aqui no modo de
‫jogo para que possamos substituir, começar, jogar.
‫Então eu vou dizer virtual void, begin, play, override, e eu posso implementá-lo aqui em tune tanks, modo de
‫jogo.
‫Sim.
‫Portanto, será anulado o início do jogo e vou usar os tanques de sintonia, o nome da classe do modo de jogo.
‫E a primeira coisa que vou fazer é chamar super begin play.
‫Dessa forma, obtemos a funcionalidade dos pais e posso obter o peão do jogador usando a estática do jogo.
‫Então, vou incluir primeiro as estáticas de jogabilidade e isso está nas estáticas de jogabilidade kismet slash, como
‫já vimos.
‫E aqui eu posso pegar o Tank e atribuir a ele o valor das estáticas de jogo da juventude.
‫Palma do guitarrista.
‫Agora, isso leva um objeto de contexto mundial para o qual podemos usar isso, e vou usar zero como
‫o índice do jogador, pois nosso tanque sempre será o jogador zero.
‫Agora sabemos que o jet player -- retorna um ponteiro A -- e o tanque é do tipo tanque A, uma classe filha.
‫E vimos que precisamos converter para isso uma classe de tanque se quisermos armazenar esse resultado em um ponteiro de tanque
‫A.
‫Então, primeiro vou incluir o cabeçalho do tanque.
‫Então eu vou dizer para incluir o tanque H e então vou lançar para um tanque.
‫Então eu vou dizer cast to a tank e estou castando o valor retornado de get player --.
‫Então eu vou colocar isso entre parênteses aqui.
‫E agora teremos um ponteiro para o jogador -- na forma de um ponteiro de tanque A.
‫Agora que temos o tanque, podemos verificar se nosso ator morto é o tanque.
‫Então, podemos dizer que se o ator morto duplo é igual a tanque agora tanque pode ser nulo.
‫E tudo bem, porque se Tank for nulo e o ator morto se referir ao próprio tanque, isso falhará na
‫verificação de if e não tentaremos acessar um ponteiro nulo porque não chegaremos ao
‫interior disso.
‫Agora, se o ator morto é de fato o tanque, então eu gostaria de chamar a função de destruição da alça do tanque.
‫Então, vamos chamar a destruição do manípulo do tanque.
‫Agora, depois de chamar a função de destruição da alça, também gostaria de desabilitar a entrada para o pod do
‫tanque para que eu possa obter o tanque e chamar a função interna que o tanque herda chamada de entrada de desativação.
‫Agora, desativar a entrada requer um controlador de jogador A.
‫Agora sabemos que a classe tank, se entrarmos aqui no tanque H, tem essa variável player controller ref, que é um
‫ponteiro para um player controller, e é por isso que estou começando a pensar que ref é um nome muito
‫ruim para essa variável .
‫Como não é uma referência, é um ponteiro.
‫Eu quase prefiro chamá-lo de controlador de jogador de tanque.
‫Então, na verdade, por que não vamos em frente e renomeamos isso?
‫Isso é algo que os desenvolvedores costumam fazer quando percebem que deram uma variável, um nome ruim.
‫Portanto, este código tem uma maneira de fazer isso facilmente.
‫Eu posso destacar essa variável e pressionar a tecla F2 e está pedindo para eu renomeá-la.
‫Vou chamar este controlador de jogador de tanque.
‫Agora verifique isso.
‫Chama-se Tank Player Controller aqui.
‫Se eu for para o Tank CP, verei que ele é renomeado aqui também.
‫Então eu não tive que ir procurá-lo e encontrar todas as instâncias de player, controller, ref.
‫Eu posso procurar pelo controlador do jogador do tanque e ver que ele mudou em todos os lugares em que é usado aqui.
‫Então, essa é uma boa habilidade de refatoração para se ter.
‫De qualquer forma, de volta aqui no modo de jogo de tanques de sintonia, eu preciso desabilitar a entrada para o tanque e isso
‫requer um controlador de jogador.
‫Então, primeiro vou verificar se o controlador do jogador do tanque é válido, dizendo se o tanque e eu
‫preciso acessar esse controlador do jogador.
‫Mas lembre-se que no tanque, nossa variável do controlador do jogador é privada.
‫Agora podemos expor isso e torná-lo público, ou podemos fazer uma função getter pública para essa variável.
‫Eu prefiro fazer um getter público, pois essa é a melhor prática de programação.
‫Então, aqui na seção pública, vou criar um getter público para o controlador do jogador de tanque.
‫Agora ele retornará um ponteiro de controlador de jogador A e esta função será chamada de
‫get tank player.
‫Os getters do controlador são normalmente o nome da variável com get na frente, e eles também são normalmente feitos
‫com custo, pois essa função não foi projetada para alterar nada nesta classe, ela apenas retornará o controlador
‫do player.
‫Então, vamos dizer retornar o controle do jogador do tanque e isso é tudo que vai fazer.
‫Agora que temos uma função getter pública para o controlador do jogador do tanque, podemos acessar o
‫controlador do jogador aqui no modo de jogo.
‫Então, vamos dizer que se o tanque pega um controlador de jogador de tanque e faz essa chamada de função aqui.
‫E se chegarmos ao interior desta declaração if, então o controlador do jogador é válido para que
‫possamos mover esta chamada para a entrada de desativação do tanque aqui e vamos passar para a entrada desabilitada o controlador do jogador
‫do tanque.
‫Então, vamos chamar tank get player controller aqui também.
‫Agora, enquanto estamos acessando o controlador do player, eu também gostaria de fazer com que os controladores do
‫player mostrassem a variável de membro booleana do cursor do mouse e defina isso como false.
‫Portanto, estamos desabilitando a entrada e também garantindo que o cursor do mouse não seja exibido.
‫Então, isso cuida de lidar com a funcionalidade para quando o tanque morrer.
‫Agora, no caso de o ator morto não ser o tanque, eu gosto de verificar se é uma instância
‫da classe torre.
‫Então eu vou adicionar um outro se aqui.
‫Então, qual será a condicional para este elseif aqui?
‫Bem, eu gostaria de ver se o ator morto pode ser escalado para uma torre A, o que significa que vou precisar incluir
‫a classe da torre.
‫Então inclua a torre.
‫E então eu vou tentar lançar.
‫Então eu vou dizer elenco, que leva colchetes e parênteses.
‫E o que estamos lançando também é uma torre e o que estamos lançando está morto.
‫Ator tentará lançar ator morto.
‫Agora podemos realmente pegar o resultado dessa conversão e atribuí-lo e criar uma variável local.
‫Aqui na condicional podemos dizer um ponteiro de torre e podemos chamar essa torre destruída e atribuir a ela o
‫valor retornado desse elenco.
‫E se fizermos isso, teremos acesso a esse ator destruído, que é nosso ator morto lançado em uma
‫torre.
‫Agora, se isso for bem-sucedido, então iremos para dentro do elseif.
‫E então podemos levar nossos destruídos.
‫Tower e podemos simplesmente chamar a destruição do punho.
‫Então agora temos uma função de ator morto aqui no modo de jogo que chama manipular destruição e também
‫lida com mais algumas funcionalidades relacionadas à morte para o tanque.
‫Então, isso cuida do passo dois.
‫A criação de uma função ator morreu e, enquanto estávamos nisso, também chamamos a destruição do identificador na
‫função ator morreu.
‫Portanto, nosso último passo é chamar o ator morto quando a saúde chegar a zero.
‫Agora para chamar essa função que existe no modo de jogo, nosso componente health vai precisar de uma variável
‫que armazene o endereço do modo de jogo.
‫Então vamos para nossa classe de componentes de saúde.
‫Aqui estão os componentes de saúde, e vou adicionar uma variável privada aqui na parte inferior.
‫E isso será do tipo A ponteiro de modo de jogo de tanques de sintonia e chamaremos isso de modo de jogo de tanques de sintonia.
‫Agora vou encaminhar para declarar isso para não ter que incluir seu arquivo de cabeçalho aqui e então precisamos
‫acessar o modo de jogo.
‫Então vamos para o componente de saúde CP e se eu rolar para cima, vejo a função de início de jogo aqui e esse é
‫o lugar perfeito para obter o modo de jogo.
‫Novamente, colocá-lo no construtor é muito cedo.
‫Precisamos ter certeza de que o modo de jogo foi construído e existe antes de tentarmos acessá-lo.
‫Agora, aqui está uma função útil na estática do jogo chamada Get Game Mode e diz que retorna a base do modo
‫de jogo atual ou nula se não puder ser recuperada, como no cliente.
‫Agora no cliente tem a ver com programação multiplayer e não precisamos nos preocupar com isso.
‫Estamos rodando na única máquina para nosso jogo, então vamos rolar para baixo e veremos que uma base de modo
‫de jogo pega um objeto de contexto mundial.
‫Este é apenas um objeto no mundo e vimos como lidar com objetos de contexto do mundo.
‫Então isso existe na jogabilidade estática h, então vamos incluir isso.
‫E aqui nos componentes de saúde, o CP colará nossa inclusão para estatísticas de jogo e, em seguida, chamaremos o modo
‫de jogo aqui e começaremos a jogar.
‫Então vamos dizer tanques de sintonia, modo de jogo.
‫E defina isso para o valor de você.
‫As estáticas de jogabilidade obtêm o modo de jogo e para o objeto de contexto do mundo.
‫Vou passar nessa e agora temos o modo de jogo.
‫Mas é claro que obter o modo de jogo, retorna uma base de modo de jogo e estamos tentando armazená-lo
‫na classe filha, um modo de jogo de tanques de sintonia, o que significa que precisaremos lançar.
‫Isso mesmo.
‫Então, precisamos dizer cast para um modo de jogo de tanques de ajuste e estamos lançando o resultado do modo de jogo get.
‫Então eu vou colocar isso entre parênteses lá.
‫E estamos usando o modo de jogo Tune Tanks.
‫Então, vou incluir esse arquivo de cabeçalho no topo.
‫Então eu vou dizer incluir.
‫Modo de jogo Tune Tanks.
‫Então temos o modo de jogo aqui no componente de saúde.
‫Estamos prontos para descer aqui em danos sofridos e verificar se nossa saúde chega a zero.
‫E, nesse caso, podemos usar nosso ponteiro de modo de jogo de tanques de ajuste para chamar a função ator
‫morreu passando o ator que morreu e este será seu desafio, então na classe do componente de saúde em danos
‫sofridos você verificará para ver se o valor da saúde atingiu zero ou ficou abaixo de zero.
‫Se for esse o caso, chame o ator morreu usando o modo de jogo.
‫Como temos um ponteiro para o modo de jogo, não se esqueça de verificar primeiro se esse ponteiro não
‫é nulo.
‫E uma vez que você chama o ator morreu, você vai precisar passar um ator.
‫Você vai passar no ator que morreu.
‫Então pause o vídeo e implemente isso na função de dano sofrido agora.
‫OK.
‫Então já subtraímos o dano da saúde.
‫Agora estamos prontos para verificar se esse valor de integridade atingiu zero.
‫Então eu vou dizer se a saúde for menor ou igual a zero F e se for esse o caso, então é
‫apropriado chamar.
‫O ator morreu agora porque precisamos verificar se o modo de jogo é válido.
‫Eu posso colocar um anúncio aqui neste se verificar e verificar se o modo de jogo de tanques de ajuste é válido.
‫Se for nulo, retornará false aqui e não alcançaremos o interior da instrução if.
‫Portanto, se chegarmos ao interior da instrução if, o modo de jogo dos tanques de ajuste é válido e a saúde chegou a
‫zero.
‫Então podemos dizer tanques de sintonia, modo de jogo.
‫E podemos chamar ator morreu.
‫E isso leva um ator e sabemos que o ator que morreu será o ator danificado.
‫Então vamos passar no ator danificado.
‫E agora podemos compilar isso e olhar para aquilo.
‫Temos uma compilação bem-sucedida.
‫Então, vamos voltar para o editor.
‫E aqui no editor, por que não vamos em frente e testamos a morte?
‫Vamos ver se consigo destruir alguns desses tanques antes de ser destruído.
‫Isso vai ser uma espécie de desafio.
‫Ah, tem um.
‫Matei um deles e peguei o segundo.
‫Ah, e eu morri.
‫Então você pode ver que este jogo é muito mais divertido agora que adicionamos morte e destruição às nossas lagoas.
‫Então isso é ótimo.
‫Ok, então o que eu quero que você faça é dar um grande tapinha nas costas, porque neste vídeo
‫nós lidamos com a Morte do Ator, que envolve bastante interação entre essas classes em nosso jogo.
‫Agora, a forma como a morte é implementada é que a lagoa simplesmente desaparece, o que significa que ainda precisamos de algumas
‫coisas.
‫Precisamos de condições de vitória e derrota.
‫Precisamos de uma maneira de mostrar ao jogador que ele ganhou ou perdeu o jogo.
‫E também precisamos desses efeitos especiais.
‫Precisamos de alguns sons, precisamos de algumas explosões.
‫Essas coisas vão acontecer muito, muito em breve.
‫Então parabéns.
‫Você já percorreu um longo caminho e faltam apenas alguns passos.
‫Vejo vocês no próximo vídeo.