1
00:00:04,090 --> 00:00:09,970
‫Entonces, si me acerco a nuestras torres, puedo ver que están dibujando esferas de depuración, lo que demuestra que están llamando

2
00:00:09,970 --> 00:00:13,780
‫a la función de disparo y lo están haciendo cada 2 segundos.

3
00:00:14,010 --> 00:00:17,290
‫Ahora, además de eso, solo están llamando a esta función.

4
00:00:17,290 --> 00:00:22,330
‫Si estoy en el rango de tiro, si vuelvo aquí, notarán que no están dibujando esferas de depuración.

5
00:00:22,330 --> 00:00:25,660
‫Así que esto también implica una verificación de distancia.

6
00:00:25,660 --> 00:00:30,430
‫Y tan pronto como estoy lo suficientemente cerca, ahí van, dibujando esas esferas de depuración.

7
00:00:30,460 --> 00:00:32,130
‫Hola y bienvenido de nuevo.

8
00:00:32,140 --> 00:00:37,930
‫Ahora ya hemos creado una función de fuego y la estamos usando en la clase de tanque porque la hemos

9
00:00:37,930 --> 00:00:40,270
‫vinculado al mapeo de acción de fuego.

10
00:00:40,270 --> 00:00:43,960
‫Pero también nos gustaría reutilizar esto con la clase torre.

11
00:00:43,960 --> 00:00:48,820
‫Ahora, en lugar de usar la entrada del usuario para la clase de torre, vamos a usar temporizadores.

12
00:00:48,820 --> 00:00:54,370
‫Vamos a crear un temporizador para la clase de torre para que el temporizador pueda llamar a la función de disparo.

13
00:00:54,370 --> 00:01:00,400
‫De vez en cuando estableceremos un número específico de segundos entre llamadas a la función de disparo.

14
00:01:00,400 --> 00:01:06,370
‫Entonces, dado que nos gustaría que la función de disparo se llame de vez en cuando en la clase de torre, debemos hablar

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

16
00:01:07,450 --> 00:01:13,240
‫Unreal Engine tiene la capacidad de establecer temporizadores usando una clase llamada F Timer Manager.

17
00:01:13,270 --> 00:01:18,670
‫Existe un administrador de temporizador mundial que administra los temporizadores en el mundo.

18
00:01:18,700 --> 00:01:26,950
‫Ahora, este administrador de temporizador mundial tiene una función llamada Establecer temporizador y establecer el temporizador toma una serie de entradas,

19
00:01:26,950 --> 00:01:29,050
‫como un controlador de temporizador.

20
00:01:29,080 --> 00:01:34,000
‫Este es un identificador de un temporizador específico administrado por el administrador del temporizador.

21
00:01:34,000 --> 00:01:40,720
‫Esto le permite al administrador tener múltiples temporizadores y podemos acceder a la información del temporizador para cada uno usando el identificador

22
00:01:40,720 --> 00:01:44,410
‫del temporizador como una especie de nombre o ID para ese temporizador.

23
00:01:44,530 --> 00:01:47,680
‫Este es un objeto de manija de temporizador tipo F.

24
00:01:47,680 --> 00:01:52,870
‫Así que creamos un controlador de temporizador y lo pasamos a la función de configuración del temporizador.

25
00:01:52,900 --> 00:01:59,560
‫Ahora, configurar el temporizador también requiere otras entradas, como la velocidad o la cantidad de tiempo que debemos

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

27
00:02:01,630 --> 00:02:05,380
‫Ahora eso es algo que va a estar en nuestra función de devolución de llamada.

28
00:02:05,380 --> 00:02:12,130
‫Creamos una función y vinculamos esta función al temporizador para que, tan pronto como haya transcurrido el tiempo suficiente, específicamente la

29
00:02:12,130 --> 00:02:16,690
‫velocidad del temporizador, se pueda llamar a nuestra función de devolución de llamada.

30
00:02:16,690 --> 00:02:22,660
‫Así que hemos visto que necesitamos algunas cosas para nuestro temporizador y vamos a colocar estas cosas en la clase de

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

32
00:02:23,140 --> 00:02:30,040
‫Así que vayamos a la Torre H y aquí, en el archivo de la Torre H, vamos a agregar algunas variables privadas.

33
00:02:30,040 --> 00:02:33,940
‫Así que justo debajo del campo de tiro, vamos a necesitar nuestro temporizador.

34
00:02:33,940 --> 00:02:40,840
‫Entonces, este es un controlador de temporizador F y podemos simplemente llamarlo controlador de temporizador de velocidad de disparo.

35
00:02:40,870 --> 00:02:44,590
‫Y también necesitamos una tasa de fuego que sea flotante.

36
00:02:44,590 --> 00:02:50,320
‫Vamos a llamar a esta velocidad de disparo y podemos inicializarla en dos puntos F.

37
00:02:50,650 --> 00:02:56,920
‫Entonces, de esa manera, tendremos una espera de dos segundos antes de que se llame a nuestra función de devolución de llamada.

38
00:02:57,040 --> 00:03:00,460
‫Y hablando de funciones de devolución de llamada, en realidad necesitamos una.

39
00:03:00,460 --> 00:03:05,500
‫Así que vamos a hacer una función nula y podemos llamar a esta condición de verificación de disparo.

40
00:03:06,010 --> 00:03:12,760
‫Así que tenemos un identificador de temporizador y tan pronto como configuramos el temporizador y comienza a funcionar, entonces tenemos 2 segundos

41
00:03:12,760 --> 00:03:17,860
‫para esperar antes de que el temporizador realmente haga que se llame a nuestra función.

42
00:03:17,860 --> 00:03:23,890
‫Y estoy llamando a esta condición de verificación de fuego porque podemos verificar si nuestra torre debería poder llamar a la

43
00:03:23,890 --> 00:03:29,620
‫función de fuego para que podamos establecer algunas condiciones que podemos verificar para asegurarnos de que se debe llamar

44
00:03:29,620 --> 00:03:30,280
‫a fuego.

45
00:03:30,280 --> 00:03:33,010
‫Ahora tenemos declarada la función de condición de incendio.

46
00:03:33,010 --> 00:03:38,710
‫Necesitamos definirlo para que podamos ir a la torre CPP y definir la función aquí.

47
00:03:38,710 --> 00:03:45,940
‫Lo colocaré debajo de Begin Play, así que le daré un cuerpo de función y un nombre de clase de torre justo antes del

48
00:03:45,940 --> 00:03:47,440
‫nombre de la función.

49
00:03:47,530 --> 00:03:53,710
‫Así que ahora tenemos una función, pero en realidad necesitamos configurar el temporizador para que ese tiempo comience a correr y

50
00:03:53,710 --> 00:03:56,530
‫la función se llame al final de ese tiempo.

51
00:03:56,530 --> 00:04:02,200
‫Y podemos configurar el temporizador aquí y comenzar a jugar para que comience a funcionar desde el comienzo del juego.

52
00:04:02,200 --> 00:04:09,910
‫Así que mencionamos el administrador de temporizador mundial y podemos acceder a él con una función llamada Obtener administrador de

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

54
00:04:10,810 --> 00:04:16,120
‫Ahora obtenga World Timer Manager, devuelve un objeto de administrador de temporizador F.

55
00:04:16,120 --> 00:04:22,300
‫Y dado que estamos usando ese tipo, necesitaremos incluir el archivo de encabezado para el administrador del temporizador F.

56
00:04:22,300 --> 00:04:26,660
‫Así que aquí está la inclusión, es simplemente el administrador del temporizador h.

57
00:04:26,680 --> 00:04:31,000
‫Y también podemos ver algunas de las funciones que pertenecen a esta clase.

58
00:04:31,000 --> 00:04:37,150
‫Así que desplácese por estos si está interesado en todas las diferentes funciones que pertenecen al administrador de

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

60
00:04:38,110 --> 00:04:44,320
‫Entonces podemos incluir este archivo de encabezado aquí arriba en la parte superior de la torre, justo debajo de los otros incluidos.

61
00:04:44,320 --> 00:04:51,220
‫Entonces, ahora que tenemos ese archivo de encabezado incluido, ahora tenemos acceso al administrador de temporizador mundial y

62
00:04:51,220 --> 00:04:55,060
‫la función que nos interesa se llama establecer temporizador.

63
00:04:55,480 --> 00:05:01,060
‫Ahora obtenga el administrador de temporizador mundial simplemente devuelve un administrador de temporizador F, no devuelve un puntero.

64
00:05:01,060 --> 00:05:03,460
‫Así que vamos a usar el punto en lugar del.

65
00:05:03,520 --> 00:05:06,430
‫Arrow y vamos a llamar set timer.

66
00:05:06,550 --> 00:05:11,080
‫Ahora el temporizador configurado tiene varias versiones o sobrecargas de funciones.

67
00:05:11,080 --> 00:05:17,230
‫Ahora vs code tiene esta ventana emergente que nos permite revisar cada sobrecarga y ver las diferentes versiones de

68
00:05:17,230 --> 00:05:18,250
‫esta función.

69
00:05:18,250 --> 00:05:24,730
‫Y la versión que me interesa primero toma un controlador de temporizador F y vamos a usar nuestro controlador de

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

71
00:05:28,480 --> 00:05:35,200
‫Ahora, el siguiente parámetro para nuestra sobrecarga de función particular será la clase de usuario, al igual que en el eje de

72
00:05:35,200 --> 00:05:37,350
‫enlace y la acción de enlace.

73
00:05:37,360 --> 00:05:43,240
‫Esta es la clase en la que estamos trabajando en la que estamos vinculando la función para la que será esto.

74
00:05:43,240 --> 00:05:50,350
‫Ahora, lo siguiente será la función de devolución de llamada que será nuestra condición de incendio de verificación de torre A,

75
00:05:50,350 --> 00:05:52,450
‫esa función que acabamos de crear.

76
00:05:52,450 --> 00:05:58,930
‫Ahora necesitamos la dirección del operador porque el temporizador establecido toma la dirección de la función.

77
00:05:58,930 --> 00:06:05,590
‫Ahora, el siguiente parámetro es un valor flotante para la tasa, esto será cuánto tiempo debe pasar antes de que se llame

78
00:06:05,590 --> 00:06:07,390
‫a nuestra devolución de llamada.

79
00:06:07,390 --> 00:06:09,910
‫Esa va a ser nuestra tasa de fuego.

80
00:06:09,910 --> 00:06:15,730
‫Y el parámetro final es un valor booleano que especificará si este temporizador debe repetirse o no.

81
00:06:16,060 --> 00:06:22,000
‫Ahora me gustaría que se llamara a nuestra función de devolución de llamada cada 2 segundos, así que quiero que este temporizador se repita.

82
00:06:22,000 --> 00:06:23,830
‫Así que voy a decir verdad.

83
00:06:24,220 --> 00:06:28,180
‫Si pasáramos en falso pasarían 2 segundos.

84
00:06:28,180 --> 00:06:30,910
‫Nuestra función se llamaría y eso sería todo.

85
00:06:30,910 --> 00:06:37,030
‫Pero como lo configuramos para que se repita, nuestra función se llamará después de 2 segundos, después de lo cual el

86
00:06:37,030 --> 00:06:42,610
‫temporizador se reiniciará, y luego de dos segundos más, la función se llamará nuevamente y continuará en bucle

87
00:06:42,610 --> 00:06:44,290
‫hasta que termine el juego.

88
00:06:44,290 --> 00:06:50,380
‫Así que ahora tenemos una función vinculada a nuestro temporizador y está configurada para ser llamada cada 2 segundos.

89
00:06:50,380 --> 00:06:55,540
‫Así que hemos vinculado una función a nuestro temporizador y se llamará cada 2 segundos.

90
00:06:55,660 --> 00:07:00,580
‫Pero nos gustaría algún tipo de prueba o confirmación de que esta función realmente se está llamando.

91
00:07:00,580 --> 00:07:06,910
‫Entonces, para su desafío en la clase de torre, ingrese a nuestra nueva función de devolución de llamada, verifique la condición del incendio.

92
00:07:06,910 --> 00:07:09,310
‫Asegúrese de que el tanque esté en el rango de fuego.

93
00:07:09,310 --> 00:07:12,970
‫Vas a comprobar la distancia desde la torre hasta el tanque.

94
00:07:12,970 --> 00:07:17,560
‫Y sabemos cómo hacer esto porque ya lo estamos haciendo en la función tick.

95
00:07:17,560 --> 00:07:22,900
‫Por lo tanto, es posible que deba mirar en la función de tic y ver cómo se hace esto para recordar,

96
00:07:22,900 --> 00:07:28,720
‫ahora verifique esa distancia, asegúrese de que estemos dentro del rango de fuego, y luego, si lo estamos, llame a la función

97
00:07:28,720 --> 00:07:31,330
‫de fuego, pause el video e implemente esto ahora.

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

99
00:07:34,680 --> 00:07:41,700
‫Así que estoy de vuelta en Tower CP y solo voy a desplazarme hacia arriba hasta la función de marca para recordarme cómo llegué

100
00:07:41,700 --> 00:07:45,620
‫a esta distancia y verifiqué si estaba dentro del alcance de fuego.

101
00:07:45,630 --> 00:07:50,420
‫Ahora podríamos simplemente reutilizar este código aquí abajo y verificar la condición del fuego.

102
00:07:50,430 --> 00:07:56,790
‫Ahora, reutilizar el código no es muy eficiente, por lo que podemos pensar en refactorizar esto, pero primero asegurémonos de que

103
00:07:56,790 --> 00:08:02,040
‫esto funcione para que podamos verificar primero nuestro puntero de tanque para asegurarnos de que sea válido.

104
00:08:02,040 --> 00:08:04,440
‫Así que voy a hacer eso aquí y verificar la condición del fuego.

105
00:08:04,440 --> 00:08:09,870
‫Voy a decir si el tanque y si el tanque es válido, lo siguiente que podemos hacer es

106
00:08:09,870 --> 00:08:14,700
‫obtener esa distancia, que es este valor aquí calculado con la función f vector dist.

107
00:08:14,700 --> 00:08:19,380
‫Así que tomaré eso y lo colocaré aquí abajo en condiciones de verificación de fuego.

108
00:08:19,380 --> 00:08:25,050
‫Ahora, lo siguiente que hacemos es verificar si la distancia es menor o igual que el alcance del fuego.

109
00:08:25,050 --> 00:08:26,610
‫Así que eso es lo que haremos aquí abajo.

110
00:08:26,610 --> 00:08:34,200
‫Diremos si la distancia es menor o igual que el alcance del fuego, y si ese es el caso, simplemente podemos llamar a

111
00:08:34,200 --> 00:08:35,820
‫la función de fuego.

112
00:08:35,820 --> 00:08:38,760
‫Así que vamos a llamar al fuego, y es tan simple como eso.

113
00:08:38,760 --> 00:08:45,120
‫Así que sigamos adelante y compilemos esto y estamos de vuelta en el editor y voy a presionar reproducir y entrar en el

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

115
00:08:46,080 --> 00:08:52,800
‫Y puedo ver que nuestras torres están dibujando esferas de depuración en la punta del barril para que podamos

116
00:08:52,800 --> 00:09:00,630
‫ver que se está llamando a esa función de disparo y funciona de la misma manera para la torre que para el tanque.

117
00:09:00,630 --> 00:09:01,740
‫Así que esto es genial.

118
00:09:01,740 --> 00:09:09,420
‫Esto nos demuestra que nuestro temporizador se está ejecutando y nuestra función de devolución de llamada se llama cada 2 segundos.

119
00:09:09,450 --> 00:09:14,910
‫Bien, entonces tenemos esta función de fuego llamada cada 2 segundos ahora en estado de control, fuego.

120
00:09:14,910 --> 00:09:21,360
‫Tenemos esta funcionalidad en la que vemos si estamos dentro del rango y estamos haciendo exactamente lo mismo aquí en

121
00:09:21,360 --> 00:09:22,830
‫la función de marca.

122
00:09:22,830 --> 00:09:26,070
‫Así que esta es una oportunidad perfecta para refactorizar.

123
00:09:26,070 --> 00:09:32,580
‫Podríamos crear algún tipo de función que nos devuelva un valor booleano si estamos dentro del alcance del tanque.

124
00:09:32,580 --> 00:09:37,710
‫Entonces, ¿por qué no seguimos adelante y rápidamente refactorizamos esto en una función de retorno alcista?

125
00:09:37,710 --> 00:09:41,430
‫Así que aquí en la Torre H, creemos una función privada.

126
00:09:41,430 --> 00:09:45,840
‫Va a devolver bool y vamos a decir en rango de fuego.

127
00:09:45,840 --> 00:09:51,480
‫Ahora, este es un juego simple y nuestra torre solo estará dentro del alcance del tanque.

128
00:09:51,480 --> 00:09:57,120
‫Entonces, esto no es ambiguo porque no hay nada más que la torre quiera verificar para ver si

129
00:09:57,120 --> 00:10:03,240
‫está dentro del rango ahora, si este fuera un juego más complicado con otras cosas para las que la

130
00:10:03,240 --> 00:10:08,340
‫torre quisiera verificar la distancia, entonces podríamos nombre esto un poco diferente, pero simplemente podemos llamarlo

131
00:10:08,340 --> 00:10:10,320
‫en el rango de fuego.

132
00:10:10,320 --> 00:10:14,130
‫Y lo que voy a hacer es implementar esto aquí en Tower.

133
00:10:14,130 --> 00:10:17,340
‫Así que sigamos adelante y creemos el cuerpo de la función.

134
00:10:17,340 --> 00:10:20,880
‫Vamos a necesitar que una torre prefije el nombre de la función.

135
00:10:20,880 --> 00:10:25,560
‫Y lo que vamos a hacer aquí es básicamente esta misma verificación de distancia.

136
00:10:25,560 --> 00:10:31,020
‫Entonces, primero vamos a verificar para asegurarnos de que el tanque sea válido con una verificación if.

137
00:10:31,020 --> 00:10:38,880
‫Ahora, si es así, entonces podemos obtener esta distancia para poder copiar esta línea y simplemente crear nuestro flotador de distancia local justo aquí

138
00:10:38,880 --> 00:10:45,690
‫y simplemente comparar esa distancia con el rango de fuego para que podamos decir si la distancia es menor o

139
00:10:45,690 --> 00:10:51,180
‫igual que el rango de fuego, y si ese es el caso, simplemente podemos devolver verdadero.

140
00:10:51,180 --> 00:10:54,780
‫Esta función puede devolver el valor verdadero.

141
00:10:54,780 --> 00:10:58,950
‫Y ahora tenemos una función a la que podemos llamar que devolverá verdadero si estamos dentro del rango.

142
00:10:58,950 --> 00:11:05,970
‫Ahora, tan pronto como presionemos esta línea de retorno verdadero aquí en la instrucción if, la función regresará.

143
00:11:05,970 --> 00:11:07,470
‫Saldremos de la función.

144
00:11:07,470 --> 00:11:10,830
‫Entonces, cualquier otra cosa después de esta declaración if no se ejecutará.

145
00:11:10,830 --> 00:11:18,720
‫Entonces, lo que podemos hacer es al final de nuestra función de rango de fuego, podemos devolver falso porque si alguna

146
00:11:18,720 --> 00:11:25,020
‫vez alcanzamos el retorno verdadero, nunca llegaremos a la línea de retorno falso aquí abajo.

147
00:11:25,020 --> 00:11:27,690
‫Simplemente saldremos temprano de la función.

148
00:11:27,690 --> 00:11:35,250
‫Pero si no estamos dentro del alcance, si esta verificación de distancia aquí falla, entonces nunca daremos con el retorno verdadero.

149
00:11:35,370 --> 00:11:39,300
‫Y llegaremos al final de la función y devolveremos false.

150
00:11:39,300 --> 00:11:45,930
‫Entonces, esta función devolverá verdadero o falso en función de si estamos dentro del rango o no, y podemos usar esto

151
00:11:45,930 --> 00:11:49,440
‫en lugar de usar código repetido en nuestras dos funciones.

152
00:11:49,440 --> 00:11:56,610
‫Entonces, aquí arriba en tick, por ejemplo, solo necesitamos una sola verificación para ver si estamos dentro del alcance antes de girar la

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

154
00:11:57,180 --> 00:12:06,240
‫Entonces, lo que podemos hacer es decir si está en el rango de fuego y si esto es cierto, estamos en el rango de fuego para que podamos llamar

155
00:12:06,240 --> 00:12:07,830
‫a la torreta giratoria.

156
00:12:07,860 --> 00:12:10,170
‫Así que pondremos eso allí mismo en la instrucción if.

157
00:12:10,170 --> 00:12:15,090
‫Y ahora todo este código es innecesario, así que simplemente podemos eliminarlo.

158
00:12:15,450 --> 00:12:19,050
‫Y ahora esto se ve mucho más limpio que lo que teníamos antes.

159
00:12:19,050 --> 00:12:23,940
‫Y luego podemos venir aquí y verificar las condiciones del incendio y hacer lo mismo.

160
00:12:23,940 --> 00:12:29,340
‫En lugar de todo esto, simplemente podemos comprobar si está en el rango de fuego.

161
00:12:31,800 --> 00:12:35,010
‫Y si lo somos, simplemente podemos llamar al fuego.

162
00:12:35,280 --> 00:12:42,270
‫Así que ahora hemos refactorizado con éxito todo ese código en una verificación que se realiza en nuestra función de rango

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

164
00:12:43,110 --> 00:12:48,750
‫Así que sigamos compilando esto de nuevo y simplemente juguemos a probarlo muy rápido para asegurarnos de que todo

165
00:12:48,750 --> 00:12:50,100
‫funciona como se esperaba.

166
00:12:50,100 --> 00:12:54,210
‫Así que vamos a seguir adelante y presionar reproducir y ponernos en el rango de fuego.

167
00:12:54,210 --> 00:12:58,110
‫Y por supuesto, estamos en rango de tiro y está funcionando correctamente.

168
00:12:58,110 --> 00:13:05,130
‫Entonces, en resumen, creamos un temporizador y cada 2 segundos llamamos a la función de disparo en la clase de

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

170
00:13:05,790 --> 00:13:08,700
‫Ahora también estamos comprobando si Tank está dentro del alcance.

171
00:13:08,700 --> 00:13:15,570
‫Por lo tanto, solo estamos llamando a la función de disparo cada 2 segundos si el tanque está dentro de la distancia de alcance del fuego.

172
00:13:15,570 --> 00:13:19,950
‫Y también vimos que estábamos usando ese control de distancia en dos funciones diferentes.

173
00:13:19,950 --> 00:13:26,670
‫Entonces lo refactorizamos en su propia función y simplemente lo llamamos para verificar si estamos dentro del rango.

174
00:13:26,670 --> 00:13:29,970
‫Así que ahora tenemos una función de disparo llamada en la clase torre.

175
00:13:29,970 --> 00:13:35,190
‫Lo siguiente que debe hacer es comenzar a generar proyectiles con nuestra función de disparo.

176
00:13:35,190 --> 00:13:38,420
‫Así que vamos a hablar de eso en el próximo video.

177
00:13:38,430 --> 00:13:39,330
‫Te veré pronto.