1
00:00:04,090 --> 00:00:09,970
‫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

2
00:00:09,970 --> 00:00:13,780
‫a função de fogo e estão fazendo isso a cada 2 segundos.

3
00:00:14,010 --> 00:00:17,290
‫Agora, além disso, eles estão apenas chamando esta função.

4
00:00:17,290 --> 00:00:22,330
‫Se eu estiver na área de tiro, se eu voltar aqui, você notará que eles não estão desenhando esferas de depuração.

5
00:00:22,330 --> 00:00:25,660
‫Portanto, isso também envolve uma verificação de distância.

6
00:00:25,660 --> 00:00:30,430
‫E assim que eu estiver perto o suficiente, bem, lá vão eles, desenhando aquelas esferas de depuração.

7
00:00:30,460 --> 00:00:32,130
‫Olá e bem-vindo de volta.

8
00:00:32,140 --> 00:00:37,930
‫Agora já criamos uma função de fogo e estamos usando isso na classe tanque porque a vinculamos

9
00:00:37,930 --> 00:00:40,270
‫ao mapeamento de ação de fogo.

10
00:00:40,270 --> 00:00:43,960
‫Mas também gostaríamos de reutilizar isso com a classe de torre.

11
00:00:43,960 --> 00:00:48,820
‫Agora, em vez de usar a entrada do usuário para a classe de torre, vamos usar temporizadores.

12
00:00:48,820 --> 00:00:54,370
‫Vamos criar um timer para a classe tower para que o timer possa chamar a função fire.

13
00:00:54,370 --> 00:01:00,400
‫De vez em quando, definiremos um número especificado de segundos entre as chamadas para a função fire.

14
00:01:00,400 --> 00:01:06,370
‫Então, como gostaríamos que a função de fogo fosse chamada de vez em quando na classe torre, precisamos falar

15
00:01:06,370 --> 00:01:07,450
‫sobre temporizadores agora.

16
00:01:07,450 --> 00:01:13,240
‫O Unreal Engine tem a capacidade de definir temporizadores usando uma classe chamada F Timer Manager.

17
00:01:13,270 --> 00:01:18,670
‫Existe um gerenciador de cronômetro mundial que gerencia cronômetros no mundo.

18
00:01:18,700 --> 00:01:26,950
‫Agora, este gerenciador de timer mundial tem uma função chamada Set Timer e set timer recebe várias entradas, como

19
00:01:26,950 --> 00:01:29,050
‫um identificador de timer.

20
00:01:29,080 --> 00:01:34,000
‫Este é um identificador para um timer específico gerenciado pelo gerenciador de timer.

21
00:01:34,000 --> 00:01:40,720
‫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

22
00:01:40,720 --> 00:01:44,410
‫cronômetro como uma espécie de nome ou ID para esse cronômetro.

23
00:01:44,530 --> 00:01:47,680
‫Este é um objeto do tipo F timer handle.

24
00:01:47,680 --> 00:01:52,870
‫Então, criamos um identificador de timer e o passamos para a função set timer.

25
00:01:52,900 --> 00:01:59,560
‫Agora, definir o temporizador também requer outras entradas, como a taxa ou a quantidade de tempo que devemos esperar

26
00:01:59,560 --> 00:02:01,630
‫antes de realmente fazer algo.

27
00:02:01,630 --> 00:02:05,380
‫Agora isso é algo que vai estar em nossa função de retorno de chamada.

28
00:02:05,380 --> 00:02:12,130
‫Criamos uma função e vinculamos essa função ao temporizador para que, assim que o tempo tenha decorrido, especificamente a

29
00:02:12,130 --> 00:02:16,690
‫taxa do temporizador, nossa função de retorno de chamada possa ser chamada.

30
00:02:16,690 --> 00:02:22,660
‫Então vimos que precisamos de algumas coisas para o nosso cronômetro e vamos colocar essas coisas na classe

31
00:02:22,660 --> 00:02:23,140
‫torre.

32
00:02:23,140 --> 00:02:30,040
‫Então vamos para a Torre H e aqui no arquivo da Torre H vamos adicionar algumas variáveis privadas.

33
00:02:30,040 --> 00:02:33,940
‫Então, logo abaixo do alcance do fogo, vamos precisar do nosso cronômetro.

34
00:02:33,940 --> 00:02:40,840
‫Portanto, este é um identificador de temporizador F e podemos simplesmente chamar esse identificador de temporizador de taxa de disparo.

35
00:02:40,870 --> 00:02:44,590
‫E também precisamos de uma cadência de tiro que seja flutuante.

36
00:02:44,590 --> 00:02:50,320
‫Vamos chamar isso de taxa de disparo e podemos inicializar isso para dois pontos F.

37
00:02:50,650 --> 00:02:56,920
‫Dessa forma, teremos uma espera de dois segundos antes que nossa função de retorno de chamada seja realmente chamada.

38
00:02:57,040 --> 00:03:00,460
‫E falando em funções de callback, nós realmente precisamos de uma.

39
00:03:00,460 --> 00:03:05,500
‫Então, vamos fazer uma função void e podemos chamar essa condição de verificação de disparo.

40
00:03:06,010 --> 00:03:12,760
‫Portanto, temos um identificador de cronômetro e, assim que definirmos o cronômetro e ele começar a ser executado, teremos 2

41
00:03:12,760 --> 00:03:17,860
‫segundos para esperar antes que o cronômetro realmente resulte na chamada de nossa função.

42
00:03:17,860 --> 00:03:23,890
‫E estou chamando esta condição de verificação de incêndio porque podemos verificar se nossa torre deve ser capaz de chamar a

43
00:03:23,890 --> 00:03:29,620
‫função de incêndio para que possamos colocar algumas condições que possamos verificar para ter certeza de que o incêndio deve

44
00:03:29,620 --> 00:03:30,280
‫ser chamado.

45
00:03:30,280 --> 00:03:33,010
‫Agora temos a função de condição de fogo declarada.

46
00:03:33,010 --> 00:03:38,710
‫Precisamos defini-lo para que possamos entrar no CPP da torre e definir a função aqui.

47
00:03:38,710 --> 00:03:45,940
‫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

48
00:03:45,940 --> 00:03:47,440
‫do nome da função.

49
00:03:47,530 --> 00:03:53,710
‫Então agora temos uma função, mas na verdade precisamos definir o cronômetro para que esse tempo comece a ser executado

50
00:03:53,710 --> 00:03:56,530
‫e a função seja chamada no final desse tempo.

51
00:03:56,530 --> 00:04:02,200
‫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.

52
00:04:02,200 --> 00:04:09,910
‫Então mencionamos o gerenciador de timer mundial e podemos acessá-lo com uma função chamada Get World Timer

53
00:04:09,910 --> 00:04:10,810
‫Manager.

54
00:04:10,810 --> 00:04:16,120
‫Agora pegue o World Timer Manager, retorna um objeto F timer manager.

55
00:04:16,120 --> 00:04:22,300
‫E como estamos usando esse tipo, precisaremos incluir o arquivo de cabeçalho para o gerenciador de cronômetro F.

56
00:04:22,300 --> 00:04:26,660
‫Então aqui está o include é simplesmente o gerenciador de timer h.

57
00:04:26,680 --> 00:04:31,000
‫E também podemos ver algumas das funções que pertencem a esta classe.

58
00:04:31,000 --> 00:04:37,150
‫Portanto, percorra-os se estiver interessado em todas as diferentes funções que pertencem ao F timer

59
00:04:37,150 --> 00:04:37,990
‫manager.

60
00:04:38,110 --> 00:04:44,320
‫Então podemos incluir este arquivo de cabeçalho aqui no topo da torre, logo abaixo dos outros includes.

61
00:04:44,320 --> 00:04:51,220
‫Agora que temos esse arquivo de cabeçalho incluído, agora temos acesso ao gerenciador de timer mundial e

62
00:04:51,220 --> 00:04:55,060
‫a função que nos interessa é chamada set timer.

63
00:04:55,480 --> 00:05:01,060
‫Agora, get world timer manager simplesmente retorna um gerenciador de timer F, mas não retorna um ponteiro.

64
00:05:01,060 --> 00:05:03,460
‫Então, vamos usar o ponto em vez do.

65
00:05:03,520 --> 00:05:06,430
‫Arrow e vamos chamar set timer.

66
00:05:06,550 --> 00:05:11,080
‫Agora set timer tem várias versões ou sobrecargas de função.

67
00:05:11,080 --> 00:05:17,230
‫Agora o código vs tem esse pop-up que nos permite passar por cada sobrecarga e ver as diferentes versões

68
00:05:17,230 --> 00:05:18,250
‫dessa função.

69
00:05:18,250 --> 00:05:24,730
‫E a versão em que estou interessado primeiro usa um identificador de temporizador F e vamos usar nosso identificador de

70
00:05:24,760 --> 00:05:28,480
‫temporizador de taxa de disparo, que declaramos na Torre H.

71
00:05:28,480 --> 00:05:35,200
‫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

72
00:05:35,200 --> 00:05:37,350
‫ligação e na ação de ligação.

73
00:05:37,360 --> 00:05:43,240
‫Esta é a classe em que estamos trabalhando na qual estamos vinculando a função para que será isso.

74
00:05:43,240 --> 00:05:50,350
‫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,

75
00:05:50,350 --> 00:05:52,450
‫aquela função que acabamos de criar.

76
00:05:52,450 --> 00:05:58,930
‫Agora precisamos do endereço do operador porque set timer pega o endereço da função.

77
00:05:58,930 --> 00:06:05,590
‫Agora o próximo parâmetro é um float para a taxa que será quanto tempo deve passar antes que

78
00:06:05,590 --> 00:06:07,390
‫nosso callback seja chamado.

79
00:06:07,390 --> 00:06:09,910
‫Essa será a nossa taxa de tiro.

80
00:06:09,910 --> 00:06:15,730
‫E o parâmetro final é um booleano que especificará se esse timer deve ou não fazer um loop.

81
00:06:16,060 --> 00:06:22,000
‫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.

82
00:06:22,000 --> 00:06:23,830
‫Então eu vou dizer verdade.

83
00:06:24,220 --> 00:06:28,180
‫Se passássemos em falso, passariam 2 segundos.

84
00:06:28,180 --> 00:06:30,910
‫Nossa função seria chamada e pronto.

85
00:06:30,910 --> 00:06:37,030
‫Mas como configuramos para fazer um loop, nossa função será chamada após 2 segundos, após os quais o cronômetro

86
00:06:37,030 --> 00:06:42,610
‫será reiniciado e, após mais dois segundos, a função será chamada novamente e continuará em loop até

87
00:06:42,610 --> 00:06:44,290
‫que o jogo termine.

88
00:06:44,290 --> 00:06:50,380
‫Então agora temos uma função ligada ao nosso timer e está configurada para ser chamada a cada 2 segundos.

89
00:06:50,380 --> 00:06:55,540
‫Então, vinculamos uma função ao nosso timer e ela será chamada a cada 2 segundos.

90
00:06:55,660 --> 00:07:00,580
‫Mas gostaríamos de algum tipo de prova ou confirmação de que esta função está realmente sendo chamada.

91
00:07:00,580 --> 00:07:06,910
‫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.

92
00:07:06,910 --> 00:07:09,310
‫Certifique-se de que o tanque está ao alcance do fogo.

93
00:07:09,310 --> 00:07:12,970
‫Você vai verificar a distância da torre ao tanque.

94
00:07:12,970 --> 00:07:17,560
‫E sabemos como fazer isso porque já estamos fazendo isso na função tick.

95
00:07:17,560 --> 00:07:22,900
‫Então você pode precisar olhar na função tick e ver como isso é feito para se lembrar,

96
00:07:22,900 --> 00:07:28,720
‫agora verifique essa distância, certifique-se de que estamos no alcance de fogo e, se estivermos, chame a função de

97
00:07:28,720 --> 00:07:31,330
‫fogo, pause o vídeo e implemente Isso agora.

98
00:07:34,320 --> 00:07:34,680
‫OK.

99
00:07:34,680 --> 00:07:41,700
‫Então, estou de volta à Torre CP e vou rolar até a função tick para me lembrar de como cheguei

100
00:07:41,700 --> 00:07:45,620
‫a essa distância e verifiquei se estava ao alcance de tiro.

101
00:07:45,630 --> 00:07:50,420
‫Agora podemos simplesmente reutilizar este código aqui e verificar a condição de incêndio.

102
00:07:50,430 --> 00:07:56,790
‫Agora, reutilizar o código não é muito eficiente, então podemos pensar em refatorar isso, mas primeiro vamos ter certeza de que estamos

103
00:07:56,790 --> 00:08:02,040
‫funcionando para que possamos primeiro verificar nosso ponteiro do tanque para ter certeza de que é válido.

104
00:08:02,040 --> 00:08:04,440
‫Então eu vou fazer isso aqui e verificar a condição do fogo.

105
00:08:04,440 --> 00:08:09,870
‫Eu vou dizer se tanque e se o tanque é válido, a próxima coisa que podemos fazer é

106
00:08:09,870 --> 00:08:14,700
‫obter essa distância, que é esse valor aqui calculado com a função dist do vetor f.

107
00:08:14,700 --> 00:08:19,380
‫Então eu vou pegar isso e colocar aqui embaixo na condição de checagem de fogo.

108
00:08:19,380 --> 00:08:25,050
‫Agora, a próxima coisa que fazemos é verificar se a distância é menor ou igual ao alcance de tiro.

109
00:08:25,050 --> 00:08:26,610
‫Então é isso que vamos fazer aqui embaixo.

110
00:08:26,610 --> 00:08:34,200
‫Diremos que se a distância for menor ou igual ao alcance de tiro, e se for esse o caso, podemos simplesmente chamar

111
00:08:34,200 --> 00:08:35,820
‫a função de tiro.

112
00:08:35,820 --> 00:08:38,760
‫Então vamos chamar fogo, e é simples assim.

113
00:08:38,760 --> 00:08:45,120
‫Então vamos em frente e compilar isso e estamos de volta ao editor e eu vou apertar o play e entrar no

114
00:08:45,120 --> 00:08:46,080
‫alcance de tiro.

115
00:08:46,080 --> 00:08:52,800
‫E eu posso ver que nossas torres estão desenhando esferas de depuração na ponta do barril para que

116
00:08:52,800 --> 00:09:00,630
‫possamos ver que essa função de fogo está sendo chamada e funciona da mesma maneira para a torre e para o tanque.

117
00:09:00,630 --> 00:09:01,740
‫Então isso é ótimo.

118
00:09:01,740 --> 00:09:09,420
‫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.

119
00:09:09,450 --> 00:09:14,910
‫Ok, então temos esta função de fogo chamada a cada 2 segundos agora em cheque, condição de fogo.

120
00:09:14,910 --> 00:09:21,360
‫Temos essa funcionalidade onde estamos vendo se estamos dentro do alcance e estamos fazendo exatamente a mesma coisa

121
00:09:21,360 --> 00:09:22,830
‫aqui na função tick.

122
00:09:22,830 --> 00:09:26,070
‫Portanto, esta é uma oportunidade perfeita para refatorar.

123
00:09:26,070 --> 00:09:32,580
‫Podemos criar algum tipo de função que nos retorne um booleano se estivermos ao alcance do tanque.

124
00:09:32,580 --> 00:09:37,710
‫Então, por que não vamos em frente e refatoramos isso rapidamente em uma função de retorno de touro?

125
00:09:37,710 --> 00:09:41,430
‫Então aqui na Torre H, vamos criar uma função privada.

126
00:09:41,430 --> 00:09:45,840
‫Vai retornar bool e vamos dizer em alcance de tiro.

127
00:09:45,840 --> 00:09:51,480
‫Agora, este é um jogo simples e nossa torre só estará ao alcance do tanque.

128
00:09:51,480 --> 00:09:57,120
‫Portanto, isso não é ambíguo porque não há mais nada que a torre gostaria de verificar para ver

129
00:09:57,120 --> 00:10:03,240
‫se está no alcance de agora, se este fosse um jogo mais complicado com outras coisas para as quais a

130
00:10:03,240 --> 00:10:08,340
‫torre gostaria de verificar a distância, então poderíamos nomeie isso um pouco diferente, mas podemos simplesmente

131
00:10:08,340 --> 00:10:10,320
‫chamá-lo no alcance de tiro.

132
00:10:10,320 --> 00:10:14,130
‫E o que eu vou fazer é implementar isso aqui no Tower.

133
00:10:14,130 --> 00:10:17,340
‫Então vamos em frente e criar o corpo da função.

134
00:10:17,340 --> 00:10:20,880
‫Vamos precisar dessa torre pré-fixando o nome da função.

135
00:10:20,880 --> 00:10:25,560
‫E o que vamos fazer aqui é basicamente essa mesma verificação de distância.

136
00:10:25,560 --> 00:10:31,020
‫Então, primeiro vamos verificar se o tanque é válido com uma verificação if.

137
00:10:31,020 --> 00:10:38,880
‫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

138
00:10:38,880 --> 00:10:45,690
‫simplesmente verificar essa distância em relação ao alcance de tiro para que possamos dizer se a distância é menor ou

139
00:10:45,690 --> 00:10:51,180
‫igual ao alcance de tiro, e se for esse o caso, podemos simplesmente retornar true.

140
00:10:51,180 --> 00:10:54,780
‫Esta função pode retornar o valor true.

141
00:10:54,780 --> 00:10:58,950
‫E agora temos uma função que podemos chamar que retornará true se estivermos dentro do alcance.

142
00:10:58,950 --> 00:11:05,970
‫Agora, assim que atingirmos essa linha return true aqui na instrução if, a função retornará.

143
00:11:05,970 --> 00:11:07,470
‫Vamos pular fora da função.

144
00:11:07,470 --> 00:11:10,830
‫Portanto, qualquer outra coisa após esta instrução if não será executada.

145
00:11:10,830 --> 00:11:18,720
‫Então, o que podemos fazer é no final da nossa função in fire range, podemos retornar false

146
00:11:18,720 --> 00:11:25,020
‫porque se chegarmos ao retorno true, nunca chegaremos à linha return false aqui.

147
00:11:25,020 --> 00:11:27,690
‫Nós simplesmente sairemos da função mais cedo.

148
00:11:27,690 --> 00:11:35,250
‫Mas se não estivermos dentro do alcance, se esta verificação de distância falhar, então nunca iremos acertar o retorno verdadeiro.

149
00:11:35,370 --> 00:11:39,300
‫E chegaremos ao final da função e retornaremos false.

150
00:11:39,300 --> 00:11:45,930
‫Portanto, esta função retornará true ou false dependendo de estarmos ou não dentro do intervalo, e podemos usar isso

151
00:11:45,930 --> 00:11:49,440
‫em vez de usar código repetido em nossas duas funções.

152
00:11:49,440 --> 00:11:56,610
‫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

153
00:11:56,610 --> 00:11:57,180
‫torre.

154
00:11:57,180 --> 00:12:06,240
‫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

155
00:12:06,240 --> 00:12:07,830
‫chamar a torre rotativa.

156
00:12:07,860 --> 00:12:10,170
‫Então, vamos colocar isso bem ali na instrução if.

157
00:12:10,170 --> 00:12:15,090
‫E agora todo esse código é desnecessário, então podemos simplesmente excluí-lo.

158
00:12:15,450 --> 00:12:19,050
‫E agora isso parece muito mais limpo do que o que tínhamos antes.

159
00:12:19,050 --> 00:12:23,940
‫E então podemos descer aqui e verificar a condição do fogo e fazer a mesma coisa.

160
00:12:23,940 --> 00:12:29,340
‫Em vez de tudo isso, podemos simplesmente verificar se está ao alcance de tiro.

161
00:12:31,800 --> 00:12:35,010
‫E se formos, podemos simplesmente chamar fogo.

162
00:12:35,280 --> 00:12:42,270
‫Portanto, agora refatoramos com sucesso todo esse código em uma verificação feita em nossa função in fire

163
00:12:42,270 --> 00:12:43,100
‫range.

164
00:12:43,110 --> 00:12:48,750
‫Então vamos em frente e compilar isso novamente e apenas testar bem rápido apenas para ter certeza de que

165
00:12:48,750 --> 00:12:50,100
‫tudo funciona como esperado.

166
00:12:50,100 --> 00:12:54,210
‫Então vamos em frente e apertar play e entrar no alcance de fogo.

167
00:12:54,210 --> 00:12:58,110
‫E, claro, estamos ao alcance de tiro e está funcionando corretamente.

168
00:12:58,110 --> 00:13:05,130
‫Então, resumindo, criamos um timer e a cada 2 segundos estamos chamando a função fire na classe

169
00:13:05,130 --> 00:13:05,760
‫tower.

170
00:13:05,790 --> 00:13:08,700
‫Agora também estamos verificando se Tank está dentro do alcance.

171
00:13:08,700 --> 00:13:15,570
‫Então, só estamos chamando a função de fogo a cada 2 segundos se o tanque estiver dentro da distância de tiro.

172
00:13:15,570 --> 00:13:19,950
‫E também vimos que estávamos usando essa verificação de distância em duas funções diferentes.

173
00:13:19,950 --> 00:13:26,670
‫Então, refatoramos em sua própria função e simplesmente chamamos isso para verificar se estamos dentro do alcance.

174
00:13:26,670 --> 00:13:29,970
‫Então agora temos uma função de fogo chamada na classe torre.

175
00:13:29,970 --> 00:13:35,190
‫A próxima coisa a fazer é realmente começar a gerar projéteis com nossa função de fogo.

176
00:13:35,190 --> 00:13:38,420
‫Então vamos falar sobre isso no próximo vídeo.

177
00:13:38,430 --> 00:13:39,330
‫Vejo você em breve.