‫Então, se eu chegar perto de nossas torres, posso ver que eles estão desenhando esferas de depuração, provando que estão chamando
‫a função de fogo e estão fazendo isso a cada 2 segundos.
‫Agora, além disso, eles estão apenas chamando esta função.
‫Se eu estiver na área de tiro, se eu voltar aqui, você notará que eles não estão desenhando esferas de depuração.
‫Portanto, isso também envolve uma verificação de distância.
‫E assim que eu estiver perto o suficiente, bem, lá vão eles, desenhando aquelas esferas de depuração.
‫Olá e bem-vindo de volta.
‫Agora já criamos uma função de fogo e estamos usando isso na classe tanque porque a vinculamos
‫ao mapeamento de ação de fogo.
‫Mas também gostaríamos de reutilizar isso com a classe de torre.
‫Agora, em vez de usar a entrada do usuário para a classe de torre, vamos usar temporizadores.
‫Vamos criar um timer para a classe tower para que o timer possa chamar a função fire.
‫De vez em quando, definiremos um número especificado de segundos entre as chamadas para a função fire.
‫Então, como gostaríamos que a função de fogo fosse chamada de vez em quando na classe torre, precisamos falar
‫sobre temporizadores agora.
‫O Unreal Engine tem a capacidade de definir temporizadores usando uma classe chamada F Timer Manager.
‫Existe um gerenciador de cronômetro mundial que gerencia cronômetros no mundo.
‫Agora, este gerenciador de timer mundial tem uma função chamada Set Timer e set timer recebe várias entradas, como
‫um identificador de timer.
‫Este é um identificador para um timer específico gerenciado pelo gerenciador de timer.
‫Isso permite que o gerente tenha vários cronômetros e podemos acessar as informações do cronômetro para cada um usando o identificador do
‫cronômetro como uma espécie de nome ou ID para esse cronômetro.
‫Este é um objeto do tipo F timer handle.
‫Então, criamos um identificador de timer e o passamos para a função set timer.
‫Agora, definir o temporizador também requer outras entradas, como a taxa ou a quantidade de tempo que devemos esperar
‫antes de realmente fazer algo.
‫Agora isso é algo que vai estar em nossa função de retorno de chamada.
‫Criamos uma função e vinculamos essa função ao temporizador para que, assim que o tempo tenha decorrido, especificamente a
‫taxa do temporizador, nossa função de retorno de chamada possa ser chamada.
‫Então vimos que precisamos de algumas coisas para o nosso cronômetro e vamos colocar essas coisas na classe
‫torre.
‫Então vamos para a Torre H e aqui no arquivo da Torre H vamos adicionar algumas variáveis privadas.
‫Então, logo abaixo do alcance do fogo, vamos precisar do nosso cronômetro.
‫Portanto, este é um identificador de temporizador F e podemos simplesmente chamar esse identificador de temporizador de taxa de disparo.
‫E também precisamos de uma cadência de tiro que seja flutuante.
‫Vamos chamar isso de taxa de disparo e podemos inicializar isso para dois pontos F.
‫Dessa forma, teremos uma espera de dois segundos antes que nossa função de retorno de chamada seja realmente chamada.
‫E falando em funções de callback, nós realmente precisamos de uma.
‫Então, vamos fazer uma função void e podemos chamar essa condição de verificação de disparo.
‫Portanto, temos um identificador de cronômetro e, assim que definirmos o cronômetro e ele começar a ser executado, teremos 2
‫segundos para esperar antes que o cronômetro realmente resulte na chamada de nossa função.
‫E estou chamando esta condição de verificação de incêndio porque podemos verificar se nossa torre deve ser capaz de chamar a
‫função de incêndio para que possamos colocar algumas condições que possamos verificar para ter certeza de que o incêndio deve
‫ser chamado.
‫Agora temos a função de condição de fogo declarada.
‫Precisamos defini-lo para que possamos entrar no CPP da torre e definir a função aqui.
‫Vou colocá-lo em begin play, então vou dar a ele um corpo de função e um nome de classe de torre logo antes
‫do nome da função.
‫Então agora temos uma função, mas na verdade precisamos definir o cronômetro para que esse tempo comece a ser executado
‫e a função seja chamada no final desse tempo.
‫E podemos definir o cronômetro aqui e começar o jogo para que ele comece a ser executado desde o início do jogo.
‫Então mencionamos o gerenciador de timer mundial e podemos acessá-lo com uma função chamada Get World Timer
‫Manager.
‫Agora pegue o World Timer Manager, retorna um objeto F timer manager.
‫E como estamos usando esse tipo, precisaremos incluir o arquivo de cabeçalho para o gerenciador de cronômetro F.
‫Então aqui está o include é simplesmente o gerenciador de timer h.
‫E também podemos ver algumas das funções que pertencem a esta classe.
‫Portanto, percorra-os se estiver interessado em todas as diferentes funções que pertencem ao F timer
‫manager.
‫Então podemos incluir este arquivo de cabeçalho aqui no topo da torre, logo abaixo dos outros includes.
‫Agora que temos esse arquivo de cabeçalho incluído, agora temos acesso ao gerenciador de timer mundial e
‫a função que nos interessa é chamada set timer.
‫Agora, get world timer manager simplesmente retorna um gerenciador de timer F, mas não retorna um ponteiro.
‫Então, vamos usar o ponto em vez do.
‫Arrow e vamos chamar set timer.
‫Agora set timer tem várias versões ou sobrecargas de função.
‫Agora o código vs tem esse pop-up que nos permite passar por cada sobrecarga e ver as diferentes versões
‫dessa função.
‫E a versão em que estou interessado primeiro usa um identificador de temporizador F e vamos usar nosso identificador de
‫temporizador de taxa de disparo, que declaramos na Torre H.
‫Agora, o próximo parâmetro para nossa sobrecarga de função específica será a classe de usuário, assim como no eixo de
‫ligação e na ação de ligação.
‫Esta é a classe em que estamos trabalhando na qual estamos vinculando a função para que será isso.
‫Agora, a próxima será a função de retorno de chamada que será nossa condição de disparo de verificação de torre A,
‫aquela função que acabamos de criar.
‫Agora precisamos do endereço do operador porque set timer pega o endereço da função.
‫Agora o próximo parâmetro é um float para a taxa que será quanto tempo deve passar antes que
‫nosso callback seja chamado.
‫Essa será a nossa taxa de tiro.
‫E o parâmetro final é um booleano que especificará se esse timer deve ou não fazer um loop.
‫Agora eu gostaria que nossa função de retorno de chamada fosse chamada a cada 2 segundos, então eu quero que esse timer faça um loop.
‫Então eu vou dizer verdade.
‫Se passássemos em falso, passariam 2 segundos.
‫Nossa função seria chamada e pronto.
‫Mas como configuramos para fazer um loop, nossa função será chamada após 2 segundos, após os quais o cronômetro
‫será reiniciado e, após mais dois segundos, a função será chamada novamente e continuará em loop até
‫que o jogo termine.
‫Então agora temos uma função ligada ao nosso timer e está configurada para ser chamada a cada 2 segundos.
‫Então, vinculamos uma função ao nosso timer e ela será chamada a cada 2 segundos.
‫Mas gostaríamos de algum tipo de prova ou confirmação de que esta função está realmente sendo chamada.
‫Então, para o seu desafio na classe de torre, acesse nossa nova função de retorno de chamada, verifique a condição de incêndio.
‫Certifique-se de que o tanque está ao alcance do fogo.
‫Você vai verificar a distância da torre ao tanque.
‫E sabemos como fazer isso porque já estamos fazendo isso na função tick.
‫Então você pode precisar olhar na função tick e ver como isso é feito para se lembrar,
‫agora verifique essa distância, certifique-se de que estamos no alcance de fogo e, se estivermos, chame a função de
‫fogo, pause o vídeo e implemente Isso agora.
‫OK.
‫Então, estou de volta à Torre CP e vou rolar até a função tick para me lembrar de como cheguei
‫a essa distância e verifiquei se estava ao alcance de tiro.
‫Agora podemos simplesmente reutilizar este código aqui e verificar a condição de incêndio.
‫Agora, reutilizar o código não é muito eficiente, então podemos pensar em refatorar isso, mas primeiro vamos ter certeza de que estamos
‫funcionando para que possamos primeiro verificar nosso ponteiro do tanque para ter certeza de que é válido.
‫Então eu vou fazer isso aqui e verificar a condição do fogo.
‫Eu vou dizer se tanque e se o tanque é válido, a próxima coisa que podemos fazer é
‫obter essa distância, que é esse valor aqui calculado com a função dist do vetor f.
‫Então eu vou pegar isso e colocar aqui embaixo na condição de checagem de fogo.
‫Agora, a próxima coisa que fazemos é verificar se a distância é menor ou igual ao alcance de tiro.
‫Então é isso que vamos fazer aqui embaixo.
‫Diremos que se a distância for menor ou igual ao alcance de tiro, e se for esse o caso, podemos simplesmente chamar
‫a função de tiro.
‫Então vamos chamar fogo, e é simples assim.
‫Então vamos em frente e compilar isso e estamos de volta ao editor e eu vou apertar o play e entrar no
‫alcance de tiro.
‫E eu posso ver que nossas torres estão desenhando esferas de depuração na ponta do barril para que
‫possamos ver que essa função de fogo está sendo chamada e funciona da mesma maneira para a torre e para o tanque.
‫Então isso é ótimo.
‫Isso está nos provando que nosso cronômetro está sendo executado e nossa função de retorno de chamada está sendo chamada a cada 2 segundos.
‫Ok, então temos esta função de fogo chamada a cada 2 segundos agora em cheque, condição de fogo.
‫Temos essa funcionalidade onde estamos vendo se estamos dentro do alcance e estamos fazendo exatamente a mesma coisa
‫aqui na função tick.
‫Portanto, esta é uma oportunidade perfeita para refatorar.
‫Podemos criar algum tipo de função que nos retorne um booleano se estivermos ao alcance do tanque.
‫Então, por que não vamos em frente e refatoramos isso rapidamente em uma função de retorno de touro?
‫Então aqui na Torre H, vamos criar uma função privada.
‫Vai retornar bool e vamos dizer em alcance de tiro.
‫Agora, este é um jogo simples e nossa torre só estará ao alcance do tanque.
‫Portanto, isso não é ambíguo porque não há mais nada que a torre gostaria de verificar para ver
‫se está no alcance de agora, se este fosse um jogo mais complicado com outras coisas para as quais a
‫torre gostaria de verificar a distância, então poderíamos nomeie isso um pouco diferente, mas podemos simplesmente
‫chamá-lo no alcance de tiro.
‫E o que eu vou fazer é implementar isso aqui no Tower.
‫Então vamos em frente e criar o corpo da função.
‫Vamos precisar dessa torre pré-fixando o nome da função.
‫E o que vamos fazer aqui é basicamente essa mesma verificação de distância.
‫Então, primeiro vamos verificar se o tanque é válido com uma verificação if.
‫Agora, se for, então podemos obter essa distância para que possamos copiar esta linha e apenas criar nosso flutuador de distância local aqui e
‫simplesmente verificar essa distância em relação ao alcance de tiro para que possamos dizer se a distância é menor ou
‫igual ao alcance de tiro, e se for esse o caso, podemos simplesmente retornar true.
‫Esta função pode retornar o valor true.
‫E agora temos uma função que podemos chamar que retornará true se estivermos dentro do alcance.
‫Agora, assim que atingirmos essa linha return true aqui na instrução if, a função retornará.
‫Vamos pular fora da função.
‫Portanto, qualquer outra coisa após esta instrução if não será executada.
‫Então, o que podemos fazer é no final da nossa função in fire range, podemos retornar false
‫porque se chegarmos ao retorno true, nunca chegaremos à linha return false aqui.
‫Nós simplesmente sairemos da função mais cedo.
‫Mas se não estivermos dentro do alcance, se esta verificação de distância falhar, então nunca iremos acertar o retorno verdadeiro.
‫E chegaremos ao final da função e retornaremos false.
‫Portanto, esta função retornará true ou false dependendo de estarmos ou não dentro do intervalo, e podemos usar isso
‫em vez de usar código repetido em nossas duas funções.
‫Então aqui em cima, por exemplo, só precisamos de uma única verificação para ver se estamos dentro do alcance antes de girar a
‫torre.
‫Então, o que podemos fazer é dizer se no alcance de tiro e se isso retornar verdadeiro, estamos no alcance de tiro, então podemos
‫chamar a torre rotativa.
‫Então, vamos colocar isso bem ali na instrução if.
‫E agora todo esse código é desnecessário, então podemos simplesmente excluí-lo.
‫E agora isso parece muito mais limpo do que o que tínhamos antes.
‫E então podemos descer aqui e verificar a condição do fogo e fazer a mesma coisa.
‫Em vez de tudo isso, podemos simplesmente verificar se está ao alcance de tiro.
‫E se formos, podemos simplesmente chamar fogo.
‫Portanto, agora refatoramos com sucesso todo esse código em uma verificação feita em nossa função in fire
‫range.
‫Então vamos em frente e compilar isso novamente e apenas testar bem rápido apenas para ter certeza de que
‫tudo funciona como esperado.
‫Então vamos em frente e apertar play e entrar no alcance de fogo.
‫E, claro, estamos ao alcance de tiro e está funcionando corretamente.
‫Então, resumindo, criamos um timer e a cada 2 segundos estamos chamando a função fire na classe
‫tower.
‫Agora também estamos verificando se Tank está dentro do alcance.
‫Então, só estamos chamando a função de fogo a cada 2 segundos se o tanque estiver dentro da distância de tiro.
‫E também vimos que estávamos usando essa verificação de distância em duas funções diferentes.
‫Então, refatoramos em sua própria função e simplesmente chamamos isso para verificar se estamos dentro do alcance.
‫Então agora temos uma função de fogo chamada na classe torre.
‫A próxima coisa a fazer é realmente começar a gerar projéteis com nossa função de fogo.
‫Então vamos falar sobre isso no próximo vídeo.
‫Vejo você em breve.