1
00:00:04,120 --> 00:00:04,510
‫Oye.

2
00:00:04,510 --> 00:00:05,440
‫Bienvenido de nuevo.

3
00:00:05,470 --> 00:00:11,740
‫Ahora nos hemos configurado con una función de devolución de llamada vinculada al delegado al recibir algún daño.

4
00:00:11,830 --> 00:00:16,210
‫Y el último paso es generar realmente ese evento de daño.

5
00:00:16,210 --> 00:00:19,690
‫Y queremos hacer esto cuando nuestro proyectil golpea algo.

6
00:00:19,690 --> 00:00:25,540
‫Una vez que transmitimos para este delegado, podemos aplicar daño a lo que golpeamos.

7
00:00:25,540 --> 00:00:32,110
‫Y vamos a transmitir este evento usando daño aplicado, que pertenece a la clase de estática del

8
00:00:32,110 --> 00:00:32,830
‫juego.

9
00:00:32,860 --> 00:00:36,310
‫Así que echemos un vistazo a la función de daño aplicada.

10
00:00:36,400 --> 00:00:44,050
‫Ahora aquí está la documentación para el daño aplicado que dice que daña al actor especificado con daño genérico.

11
00:00:44,050 --> 00:00:47,590
‫Así que esta es una función genérica para aplicar daño.

12
00:00:47,590 --> 00:00:52,510
‫Y lo que hagamos en respuesta a la transmisión de este delegado depende de nosotros.

13
00:00:52,540 --> 00:00:59,140
‫Ahora aquí vemos que necesitamos incluir estadísticas de juego y en la sintaxis vemos varios parámetros de entrada.

14
00:00:59,140 --> 00:01:02,110
‫Ahora obtenemos una descripción de los parámetros.

15
00:01:02,110 --> 00:01:08,290
‫Si seguimos desplazándonos hacia abajo, vemos que el actor dañado está bien, el actor que

16
00:01:08,290 --> 00:01:13,660
‫sufrirá daño base es el daño base para aplicar documentación realmente descriptiva aquí.

17
00:01:13,690 --> 00:01:14,170
‫Gracias.

18
00:01:14,170 --> 00:01:19,930
‫El instigador del evento épico es el controlador responsable de causar este daño.

19
00:01:19,930 --> 00:01:23,020
‫Y dice, por ejemplo, el jugador que disparó el arma.

20
00:01:23,020 --> 00:01:26,260
‫Cuando dice jugador, se refiere a ese controlador.

21
00:01:26,260 --> 00:01:31,120
‫Luego tenemos al causante del daño, que es el actor que realmente causó el daño.

22
00:01:31,120 --> 00:01:33,160
‫Dice la granada que explotó.

23
00:01:33,160 --> 00:01:35,980
‫En nuestro caso, será el proyectil que explotó.

24
00:01:35,980 --> 00:01:43,000
‫Y finalmente, tenemos la clase de tipo de daño, que es una clase que describe el daño que se hizo.

25
00:01:43,000 --> 00:01:49,690
‫Ahora retrocedamos en la sección de sintaxis, podemos ver los tipos de estas entradas y vemos que la clase de tipo

26
00:01:49,690 --> 00:01:56,350
‫de daño es una subclase de y hemos visto antes que la subclase TW de satisfará un parámetro de entrada de

27
00:01:56,350 --> 00:01:57,550
‫clase tipo U.

28
00:01:57,550 --> 00:02:03,730
‫Bueno, cuando llamamos a aplicar daño, podemos pasar una clase U que representa el tipo de daño que nos gustaría

29
00:02:03,730 --> 00:02:04,360
‫usar.

30
00:02:04,360 --> 00:02:09,280
‫Así que hablaremos sobre cómo vamos a satisfacer este parámetro de entrada en un momento.

31
00:02:09,280 --> 00:02:15,190
‫Entonces, la función de estática del juego de tono, el daño aplicado requerirá algunos parámetros de entrada.

32
00:02:15,190 --> 00:02:20,920
‫Entonces, diseñemos una estrategia sobre cómo vamos a pasar los valores apropiados cuando llamemos a esta

33
00:02:20,920 --> 00:02:24,100
‫función, vimos que primero necesitamos al actor dañado.

34
00:02:24,310 --> 00:02:30,220
‫Bueno, volvamos al CP de proyectil donde nos gustaría llamar aplicar daño.

35
00:02:30,220 --> 00:02:34,660
‫Nos gustaría hacerlo aquí de inmediato y ya no necesitamos estos registros.

36
00:02:34,660 --> 00:02:42,190
‫Así que simplemente voy a eliminarlos y notar que nuestra devolución de llamada al momento recibe algunas entradas una vez

37
00:02:42,190 --> 00:02:43,450
‫que se llama.

38
00:02:43,450 --> 00:02:49,240
‫Cuando se transmita el delegado de hit del componente, veremos que tenemos otro actor.

39
00:02:49,240 --> 00:02:55,930
‫Entonces tenemos acceso al actor que fue alcanzado por el proyectil y este es el actor al que nos

40
00:02:55,940 --> 00:02:56,740
‫gustaría dañar.

41
00:02:56,740 --> 00:02:59,320
‫Entonces eso se ocupa del primer parámetro de entrada.

42
00:02:59,320 --> 00:03:01,390
‫Va a ser ese otro actor.

43
00:03:01,390 --> 00:03:07,990
‫A continuación, necesitamos la cantidad de daño, lo que significa que nuestro proyectil debe tener una variable de daño

44
00:03:07,990 --> 00:03:10,360
‫para que sepamos cuánto daño aplicar.

45
00:03:10,510 --> 00:03:17,650
‫Entonces, ¿por qué no entramos en FX de proyectil y agregamos una variable de daño y esto puede ser un flotador?

46
00:03:17,650 --> 00:03:23,770
‫Así que simplemente podemos llamar a este daño y podemos inicializarlo a un valor, digamos algo como 50

47
00:03:24,040 --> 00:03:29,890
‫F y dado que esto es algo con lo que probablemente querríamos experimentar, podemos darle una propiedad

48
00:03:29,890 --> 00:03:32,860
‫U para exponerlo y editarlo. en cualquier sitio.

49
00:03:32,860 --> 00:03:37,780
‫Así que ahora tenemos una cantidad de daño para pasar cuando llamamos a recibir daño.

50
00:03:38,080 --> 00:03:44,140
‫Ahora el siguiente parámetro es el instigador y vimos que este es un controlador tipo A.

51
00:03:44,140 --> 00:03:46,870
‫Entonces, ¿cómo vamos a obtener el controlador?

52
00:03:46,870 --> 00:03:53,470
‫Bueno, hemos visto que podemos obtener el propietario de un componente en particular con la función obtener propietario.

53
00:03:53,470 --> 00:04:00,820
‫Y esto devuelve al actor que posee un componente en particular, estos proyectiles se generan dinámicamente.

54
00:04:00,820 --> 00:04:06,640
‫Entonces, debemos asegurarnos de que si vamos a llamar a obtener propietario, el propietario está configurado ahora que estamos generando

55
00:04:06,640 --> 00:04:08,410
‫estos desde el peón base.

56
00:04:08,410 --> 00:04:10,390
‫Así que si vamos al peón base.

57
00:04:10,600 --> 00:04:18,880
‫CP Aquí está la línea en la que generamos al actor, pero Spawn Actor también devuelve un puntero al actor que se

58
00:04:18,880 --> 00:04:22,690
‫generó para que podamos almacenarlo en una variable local.

59
00:04:22,690 --> 00:04:29,220
‫Por ejemplo, podríamos decir proyectil automático y asignar el valor devuelto por el actor de generación.

60
00:04:29,230 --> 00:04:35,770
‫Ahora, si no está familiarizado con auto, permite que el compilador descubra el tipo para asignar a esta

61
00:04:35,770 --> 00:04:36,790
‫nueva variable.

62
00:04:36,790 --> 00:04:42,620
‫Si pasa el cursor sobre él, verá que tiene el puntero de proyectil tipo A porque eso es lo que

63
00:04:42,670 --> 00:04:45,610
‫estamos firmando desde la función de actor de generación.

64
00:04:45,610 --> 00:04:52,960
‫Así que esto es lo mismo que si hubiéramos puesto un puntero de proyectil aquí y ahora podemos acceder a ese

65
00:04:52,960 --> 00:04:54,400
‫proyectil recién generado.

66
00:04:54,400 --> 00:04:57,820
‫Y la razón por la que queremos hacer eso es que nos gustaría establecer su propietario.

67
00:04:57,820 --> 00:05:02,710
‫Nos gustaría asegurarnos de que su propietario esté configurado para el peón que lo generó.

68
00:05:02,920 --> 00:05:04,930
‫Entonces podemos decir proyectil.

69
00:05:04,930 --> 00:05:08,010
‫Y hay una función para esto llamada propietario del conjunto.

70
00:05:08,020 --> 00:05:15,400
‫El propietario del conjunto toma un actor y vamos a pasar esto para que cada vez que uno de nuestros peones genere

71
00:05:15,400 --> 00:05:18,250
‫un proyectil, establecerá el propietario de ese proyectil.

72
00:05:18,250 --> 00:05:23,380
‫De esa manera, si alguna vez llamamos a obtener propietario más adelante, obtendremos la instancia de

73
00:05:23,380 --> 00:05:25,700
‫la clase que posee ese proyectil.

74
00:05:25,720 --> 00:05:33,190
‫Entonces, aquí en el proyectil DHCP, tenemos nuestra llamada a la función de obtener propietario y podemos almacenarla en una variable

75
00:05:33,190 --> 00:05:33,910
‫local.

76
00:05:33,940 --> 00:05:40,600
‫Continuaré y usaré auto nuevamente y llamaré a esto mi propietario y lo estableceré en el resultado devuelto por

77
00:05:40,600 --> 00:05:41,590
‫obtener propietario.

78
00:05:41,920 --> 00:05:47,570
‫Así que ahora tenemos un puntero de actor local que almacena el valor del propietario.

79
00:05:47,590 --> 00:05:52,190
‫Ahora podemos acceder al controlador del instigador desde este actor.

80
00:05:52,210 --> 00:05:57,640
‫Ahora, antes de hacerlo, es una buena idea verificar que mi propietario no sea nulo.

81
00:05:57,640 --> 00:06:04,460
‫Así que voy a decir que si mi propietario es nulo es igual a un puntero nulo, simplemente regresaré.

82
00:06:04,480 --> 00:06:09,640
‫Ahora, si el cuerpo tiene una sola declaración como esta, puede colocarla en la misma línea sin las llaves

83
00:06:09,640 --> 00:06:11,890
‫en caso de que no lo sepa.

84
00:06:11,890 --> 00:06:19,470
‫Y el puntero nulo es una palabra clave en C++ que le permite verificar si un puntero es un puntero nulo.

85
00:06:19,480 --> 00:06:25,760
‫Entonces, si mi propietario es nulo, saldremos de la función antes y no haremos nada más.

86
00:06:25,780 --> 00:06:31,030
‫Ahora, como decía, podemos obtener el controlador instigador de mi propietario y ese

87
00:06:31,030 --> 00:06:35,500
‫es el uso de la función llamada obtener controlador instigador.

88
00:06:36,400 --> 00:06:40,590
‫Y si pasamos el cursor sobre esto, veremos que devuelve un puntero de controlador A.

89
00:06:40,600 --> 00:06:48,250
‫Simplemente usaré auto y almacenaré esto en una variable local que llamaré instigador de mi propietario.

90
00:06:50,660 --> 00:06:54,460
‫Así que ahora sabemos qué pasar como instigador.

91
00:06:54,470 --> 00:07:00,800
‫La siguiente entrada es el causante del daño y este es el actor que hace el daño por el proyectil.

92
00:07:00,800 --> 00:07:02,930
‫Esto va a ser simplemente esto.

93
00:07:02,930 --> 00:07:07,490
‫Y eso deja el último parámetro de entrada, que es un tipo de daño.

94
00:07:07,490 --> 00:07:12,740
‫Y vimos que es una subclase de lo que significa que necesitamos la clase de uso adecuado para pasar.

95
00:07:12,740 --> 00:07:17,960
‫N Ahora aquí está la documentación del motor irreal para su tipo de daño.

96
00:07:17,960 --> 00:07:24,050
‫Dice que un tipo de daño tiene la intención de definir y describir una forma particular de daño y

97
00:07:24,050 --> 00:07:28,370
‫proporcionar una vía para personalizar las respuestas al daño de varias fuentes.

98
00:07:28,370 --> 00:07:30,890
‫Ahora, no vamos a personalizar nuestro daño.

99
00:07:30,890 --> 00:07:38,090
‫Solo necesitamos satisfacer el parámetro de entrada, lo que significa que necesitamos un valor de clase U que represente esta

100
00:07:38,090 --> 00:07:40,070
‫clase de tipo de daño.

101
00:07:40,310 --> 00:07:48,200
‫Ahora, en C++, si queremos obtener la clase TÚ de cualquier clase en particular, como tu tipo de daño, podemos

102
00:07:48,200 --> 00:07:51,020
‫llamar a una función llamada clase estática.

103
00:07:51,020 --> 00:07:54,140
‫Esto se hereda de la clase de su objeto.

104
00:07:54,170 --> 00:07:58,070
‫Ahora, por supuesto, estamos usando su tipo de daño aquí, así que necesitaremos ese encabezado.

105
00:07:58,310 --> 00:08:05,690
‫Entonces, de la documentación, copiaré la línea de inclusión y la pegaré aquí en la parte superior del

106
00:08:05,960 --> 00:08:14,450
‫CP del proyectil. Y ahora verá que esta función de clase estática devuelve un puntero de clase U y esa nueva clase

107
00:08:14,450 --> 00:08:17,780
‫representará el nuevo tipo de daño. clase C++.

108
00:08:17,780 --> 00:08:23,510
‫Ahora, dado que no estamos creando un plano basado en su tipo de daño y configurando algunos datos adicionales,

109
00:08:23,510 --> 00:08:26,030
‫realmente no necesitamos una subclase de variable.

110
00:08:26,150 --> 00:08:32,750
‫Entonces, en este caso, podemos usar una clase estática y esto devolverá una clase U que representa este tipo.

111
00:08:32,750 --> 00:08:38,480
‫Y podemos almacenar esto en una variable si queremos, y lo llamaré clase de tipo de daño.

112
00:08:40,390 --> 00:08:45,520
‫Y esto es lo que podemos pasar como parámetro final para aplicar daño.

113
00:08:45,520 --> 00:08:51,250
‫Así que ahora tenemos toda la información que necesitamos para pasar a la función de aplicar daño.

114
00:08:51,250 --> 00:08:57,100
‫Pero antes de hacerlo, me gustaría hacer un par de comprobaciones para asegurarme de que sea apropiado que llamemos a

115
00:08:57,100 --> 00:08:58,000
‫esta función.

116
00:08:58,000 --> 00:09:00,090
‫Así que haré una declaración if aquí.

117
00:09:00,100 --> 00:09:03,550
‫Primero, quiero asegurarme de que otro actor no sea nulo.

118
00:09:03,550 --> 00:09:06,490
‫Así que voy a colocar a otro actor aquí.

119
00:09:06,490 --> 00:09:13,450
‫Voy a colocar un y aquí para poder verificar que otro actor no sea igual a este actor.

120
00:09:13,450 --> 00:09:19,840
‫No queremos causarnos daño a nosotros mismos si somos el proyectil ahora voy a colocar otro extremo

121
00:09:19,840 --> 00:09:24,640
‫y asegurarme de que otro actor no sea igual a mi dueño.

122
00:09:24,760 --> 00:09:28,930
‫No sería bueno que el proyectil esté causando daño a su dueño.

123
00:09:28,930 --> 00:09:35,200
‫Y ahora, si entramos en esta instrucción if, entonces sabemos que es apropiado llamar a aplicar daño para

124
00:09:35,200 --> 00:09:36,550
‫que podamos hacerlo.

125
00:09:36,550 --> 00:09:38,290
‫Y ese va a ser tu desafío.

126
00:09:38,290 --> 00:09:45,070
‫Entonces, en nuestra nueva declaración if en la función on hit, llame a la función de daño de aplicación de estática de juego.

127
00:09:45,070 --> 00:09:51,310
‫Esto significa que deberá incluir el encabezado correcto para las estadísticas del juego y sabrá qué parámetros

128
00:09:51,310 --> 00:09:52,450
‫de entrada pasar.

129
00:09:52,570 --> 00:09:58,660
‫Así que pause el video y agregue la llamada de función para aplicar daño en la función de golpe ahora.

130
00:10:02,740 --> 00:10:03,250
‫Bueno.

131
00:10:03,250 --> 00:10:11,020
‫Así que estoy aquí en CP de proyectiles y voy a incluir el archivo de encabezado para las estadísticas del juego y podemos ver

132
00:10:11,020 --> 00:10:17,260
‫en la página de Documentación de daños aplicados que la inclusión es la estática del juego kismet slash.

133
00:10:17,980 --> 00:10:22,330
‫Así que voy a pegar eso allí y ahora estoy listo para aplicar daño.

134
00:10:22,330 --> 00:10:28,060
‫Así que te llamaré estática del juego que aplica daño.

135
00:10:28,810 --> 00:10:35,140
‫Ahora, tan pronto como escribo los paréntesis de apertura, aparece una ventana emergente que me recuerda los parámetros de entrada

136
00:10:35,140 --> 00:10:35,800
‫que necesito.

137
00:10:35,800 --> 00:10:40,360
‫Y el primero es el actor dañado y ese va a ser otro actor.

138
00:10:40,360 --> 00:10:42,760
‫Así que vamos a escribir otro actor a continuación.

139
00:10:42,760 --> 00:10:50,410
‫Necesitamos la cantidad de daño y agregamos este daño flotante en los efectos especiales del proyectil, que establecemos en 50.

140
00:10:50,410 --> 00:10:53,170
‫Así que voy a pasar el final del daño a continuación.

141
00:10:53,170 --> 00:10:56,920
‫Necesitamos al instigador y tenemos a mi dueño instigador.

142
00:10:56,920 --> 00:11:00,010
‫Así que voy a pasar a mi dueño instigador.

143
00:11:00,010 --> 00:11:01,960
‫El siguiente es el causante del daño.

144
00:11:01,960 --> 00:11:05,500
‫Y por supuesto, el propio proyectil es el causante del daño.

145
00:11:05,500 --> 00:11:07,210
‫Así que vamos a pasar en esto.

146
00:11:07,210 --> 00:11:14,860
‫Y finalmente necesitamos la subclase de para su tipo de daño que sabemos que un puntero de clase U satisfará eso y es por

147
00:11:14,860 --> 00:11:17,980
‫eso que tenemos nuestra clase de tipo de daño.

148
00:11:17,980 --> 00:11:21,910
‫Así que pasemos a la clase de tipo de daño.

149
00:11:21,910 --> 00:11:25,570
‫Y con eso ahora estamos llamando a aplicar daño.

150
00:11:25,720 --> 00:11:33,040
‫Entonces, cuando llamemos a esto, generaremos el evento de daño y el delegado de tomar cualquier daño se transmitirá en respuesta

151
00:11:33,040 --> 00:11:39,010
‫a esto, lo que significa que en nuestro componente de salud se llamará el daño recibido.

152
00:11:39,010 --> 00:11:42,580
‫Así que solo tenemos que hacer algo aquí en el daño recibido.

153
00:11:42,580 --> 00:11:47,440
‫Bueno, tendría sentido tomar este daño y restar esa cantidad de la salud.

154
00:11:47,440 --> 00:11:52,510
‫Sin embargo, antes de hacer eso, me gustaría asegurarme de que el daño no sea menor o igual a cero.

155
00:11:52,810 --> 00:11:59,170
‫F Tiene sentido hacer estas comprobaciones antes de documentar los daños, solo para asegurarnos de que no aplicamos un valor

156
00:11:59,170 --> 00:12:02,890
‫que no tiene ningún sentido, como cero o un valor negativo.

157
00:12:02,890 --> 00:12:05,740
‫Entonces, si ese es el caso, simplemente regresaremos.

158
00:12:05,740 --> 00:12:11,800
‫Y, por supuesto, si desea ser astuto y hacer lo que hice en proyectiles en CP, podemos colocar el retorno

159
00:12:11,800 --> 00:12:12,700
‫allí mismo.

160
00:12:12,700 --> 00:12:19,840
‫Ahora, si superamos esta línea, el daño es un valor positivo, por lo que podemos tomar salud y usar menos

161
00:12:19,840 --> 00:12:21,460
‫es igual a daño.

162
00:12:21,550 --> 00:12:25,750
‫Y solo para asegurarnos de que esto funciona, ¿por qué no colocamos un registro euy aquí?

163
00:12:25,750 --> 00:12:37,960
‫Así que el registro de registro de Yui, el texto de advertencia temporal y simplemente podemos imprimir el valor de la salud con el porcentaje F y la

164
00:12:37,960 --> 00:12:40,840
‫salud y con eso podemos compilar.

165
00:12:40,870 --> 00:12:47,200
‫Ahora, con una compilación exitosa, volveremos al editor y con nuestro registro de salida abierto, presionemos

166
00:12:47,200 --> 00:12:47,980
‫reproducir.

167
00:12:47,980 --> 00:12:51,010
‫Ahora veamos si podemos ser alcanzados por un proyectil.

168
00:12:51,010 --> 00:12:52,120
‫Y ahí vamos.

169
00:12:52,150 --> 00:12:58,810
‫Nuestra salud ahora está en 50 y, si nos golpean de nuevo, obtendremos bastantes eventos de golpe

170
00:12:58,810 --> 00:13:02,410
‫porque chocamos contra el proyectil muchas veces muy rápido.

171
00:13:02,410 --> 00:13:05,770
‫Pero vemos que nuestra salud se está documentando correctamente.

172
00:13:05,770 --> 00:13:11,620
‫Por lo tanto, debemos asegurarnos de implementar el comportamiento correcto después de la muerte cuando la salud llega a cero.

173
00:13:11,620 --> 00:13:17,290
‫Pero también debemos asegurarnos de que este evento exitoso no se envíe spam varias veces.

174
00:13:17,290 --> 00:13:23,560
‫Ahora sabemos que el proyectil debe destruirse al golpear algo, por lo que la mejor manera de evitar el envío

175
00:13:23,560 --> 00:13:26,800
‫de spam al evento de impacto es destruir el proyectil.

176
00:13:26,800 --> 00:13:29,290
‫Eso es lo último que haremos en este video.

177
00:13:29,290 --> 00:13:36,460
‫Entonces, de vuelta en el proyectil justo después de aplicar el daño, lo que podemos hacer es que el proyectil se destruya a sí mismo y eso

178
00:13:36,460 --> 00:13:38,050
‫no podría ser más fácil.

179
00:13:38,050 --> 00:13:41,110
‫Simplemente llamamos a la función destroy.

180
00:13:41,110 --> 00:13:48,880
‫Entonces, con una compilación más aquí en el editor, podemos seguir adelante y ser golpeados por un proyectil y mirar

181
00:13:48,880 --> 00:13:49,330
‫eso.

182
00:13:49,330 --> 00:13:51,520
‫El proyectil se ha ido.

183
00:13:51,520 --> 00:13:55,360
‫Entonces hace su daño y luego desaparece.

184
00:13:55,360 --> 00:14:02,110
‫Y, por supuesto, también podemos probar golpear las torres haciéndolas estallar con proyectiles y asegurándonos de que

185
00:14:02,110 --> 00:14:04,570
‫esos eventos de golpe se activen.

186
00:14:04,570 --> 00:14:10,750
‫Y como puede ver, puedo enviar spam a esto con un montón de proyectiles y veremos que

187
00:14:10,750 --> 00:14:16,390
‫el valor de salud de esta pobre torre aquí se está volviendo muy, muy negativo.

188
00:14:16,540 --> 00:14:23,650
‫Entonces, en resumen, llamamos a la función de aplicar daño y esto resultó en una transmisión para el delegado de

189
00:14:23,650 --> 00:14:25,030
‫tomar cualquier daño.

190
00:14:25,030 --> 00:14:30,130
‫Documentamos la salud en el componente sanitario y destruimos el proyectil.

191
00:14:30,130 --> 00:14:32,350
‫Así que ahora nos hemos ocupado de los daños.

192
00:14:32,350 --> 00:14:34,390
‫Todavía no nos hemos ocupado de la muerte.

193
00:14:34,390 --> 00:14:38,860
‫Esa será una de las próximas cosas que cubriremos en un video futuro.

194
00:14:39,310 --> 00:14:40,270
‫Te veré pronto.