1
00:00:04,170 --> 00:00:04,650
‫Oye.

2
00:00:04,650 --> 00:00:05,610
‫Bienvenido de nuevo.

3
00:00:05,640 --> 00:00:11,010
‫Ahora tenemos nuestro proyectil y sabemos que está generando eventos de impacto, por lo que debemos hacer

4
00:00:11,010 --> 00:00:14,250
‫algo cuando el proyectil realmente impacte en nuestro objetivo.

5
00:00:14,280 --> 00:00:19,200
‫Ahora, eso implicará hacer daño, lo que significa que necesitamos una forma de realizar un seguimiento de la salud.

6
00:00:19,200 --> 00:00:24,840
‫Así que vamos a crear una clase para manejar la salud y el daño llamada componente de salud.

7
00:00:24,930 --> 00:00:30,720
‫Y la razón por la que esta funcionalidad tiene su propia clase es que podemos reutilizarla para diferentes clases,

8
00:00:30,720 --> 00:00:32,690
‫como el tanque y la torre.

9
00:00:32,700 --> 00:00:35,250
‫Así que hablemos de este componente de salud.

10
00:00:35,640 --> 00:00:38,900
‫Ahora estamos familiarizados con la clase de componente de escena de uso.

11
00:00:38,910 --> 00:00:43,390
‫Bueno, esta clase se deriva de una clase llamada componente actor.

12
00:00:43,410 --> 00:00:47,220
‫De hecho, aquí está la documentación del componente de escena de uso.

13
00:00:47,220 --> 00:00:53,100
‫Y en la jerarquía de herencia, puede ver que su padre es su componente de actor.

14
00:00:53,130 --> 00:00:57,330
‫Ahora el componente que actúas es más básico que el componente que has visto.

15
00:00:57,420 --> 00:00:59,070
‫No tiene transformación.

16
00:00:59,070 --> 00:01:05,020
‫Entonces, la ubicación, la rotación y la escala no son algo que el componente de tu actor tenga.

17
00:01:05,040 --> 00:01:06,930
‫No admite archivos adjuntos.

18
00:01:06,930 --> 00:01:12,660
‫No puede adjuntar un componente activo a, por ejemplo, un componente de malla estática o un componente de cápsula.

19
00:01:12,660 --> 00:01:15,180
‫Es algo que pertenece al actor.

20
00:01:15,180 --> 00:01:20,910
‫Y debido a que no hay representación visual o transformación, no necesitamos adjuntarlo a nada.

21
00:01:21,000 --> 00:01:27,060
‫Compare esto con el componente de escena de uso, que en realidad tiene una transformación y la capacidad de

22
00:01:27,060 --> 00:01:31,640
‫adjuntarse a otros componentes o hacer que otros componentes se adhieran a él.

23
00:01:31,650 --> 00:01:36,450
‫Entonces, para hacer un seguimiento de la salud y cuidar los daños, no necesitamos ninguna de esas cosas.

24
00:01:36,450 --> 00:01:39,990
‫Así que actúas como un componente que será perfecto para esto.

25
00:01:40,170 --> 00:01:44,880
‫Así que volvamos al editor y hagamos de nuestro nuevo acto una clase de componente.

26
00:01:44,880 --> 00:01:48,690
‫Así que subiremos a las herramientas y la nueva clase de C++.

27
00:01:48,690 --> 00:01:51,890
‫Y si me desplazo hacia abajo, puedo ver el componente actor.

28
00:01:51,900 --> 00:01:53,730
‫Esto es lo que vamos a seleccionar.

29
00:01:53,760 --> 00:01:54,630
‫Ahora ten cuidado.

30
00:01:54,630 --> 00:01:56,400
‫No seleccione actor.

31
00:01:56,400 --> 00:01:57,750
‫Esa es una clase diferente.

32
00:01:57,750 --> 00:02:02,610
‫En realidad, es una clase más grande y tiene muchas más cosas que el componente actor.

33
00:02:02,610 --> 00:02:07,560
‫Necesitamos el componente actor específicamente, así que seleccione eso, haga clic en siguiente.

34
00:02:07,560 --> 00:02:11,490
‫Y esto lo podemos llamar simplemente Componente de Salud.

35
00:02:11,880 --> 00:02:13,740
‫Hagamos clic en Crear clase.

36
00:02:14,190 --> 00:02:21,420
‫Ahora aquí tenemos nuestros nuevos componentes de salud y archivos CP y puede ver aquí que su componente de salud, la

37
00:02:21,420 --> 00:02:25,980
‫clase que acabamos de crear se deriva de su acto como componente.

38
00:02:25,980 --> 00:02:30,390
‫Así que asegúrate de tener el tipo correcto aquí y verás que tiene en su U.

39
00:02:30,390 --> 00:02:31,710
‫Macro de clase.

40
00:02:31,740 --> 00:02:36,360
‫Este meta especifica dónde y dice el componente de la tabla de generación de planos.

41
00:02:36,360 --> 00:02:41,790
‫Esto es lo que nos permitirá agregar este componente directamente en los planos, que es lo

42
00:02:41,790 --> 00:02:43,050
‫que haremos ahora.

43
00:02:43,050 --> 00:02:48,960
‫El nuevo componente de salud se ocupará de la salud, lo que significa que necesitamos un par de variables.

44
00:02:48,960 --> 00:02:52,380
‫Avancemos y agreguemos estos y los haré privados.

45
00:02:52,380 --> 00:02:58,500
‫Así que sigamos adelante y agreguemos una sección privada justo debajo de la protegida, y podemos agregar un par de

46
00:02:58,500 --> 00:02:59,700
‫variables de salud.

47
00:02:59,700 --> 00:03:04,290
‫Ahora, estos van a ser flotadores y voy a llamar al primero Max Health.

48
00:03:04,320 --> 00:03:10,440
‫Esta será la cantidad máxima de salud que podemos tener y podemos establecer esto en un valor

49
00:03:10,440 --> 00:03:12,180
‫predeterminado como 100 F.

50
00:03:12,180 --> 00:03:18,000
‫Ahora, además de la salud máxima, vamos a tener un valor de salud que será la salud actual y esto

51
00:03:18,000 --> 00:03:20,850
‫será lo que cambie a medida que recibamos daño.

52
00:03:20,850 --> 00:03:24,720
‫Así que hagamos otro flotador y simplemente llamemos a este salud.

53
00:03:24,720 --> 00:03:30,900
‫Ahora podemos inicializar la salud a cero F y luego establecer su valor y comenzar a jugar.

54
00:03:30,900 --> 00:03:37,380
‫Y la razón por la que lo haremos es porque Max Health tendrá su propia propiedad que nos permitirá

55
00:03:37,380 --> 00:03:39,690
‫configurarla desde el panel de detalles.

56
00:03:39,690 --> 00:03:43,470
‫Así que démosle a esto una propiedad U y hagamos que se edite en cualquier lugar.

57
00:03:43,680 --> 00:03:46,500
‫De esa manera podemos cambiarlo a medida que nos desarrollamos.

58
00:03:46,500 --> 00:03:53,700
‫Y luego, en los componentes de salud CP aquí y comenzar a jugar, simplemente podemos establecer la salud igual al valor de la

59
00:03:53,700 --> 00:03:54,600
‫salud máxima.

60
00:03:54,600 --> 00:04:00,390
‫De esa manera, cuando comience el juego, la salud tendrá el valor de salud máxima incluso después de que lo hayamos cambiado

61
00:04:00,390 --> 00:04:01,860
‫en el panel de detalles.

62
00:04:02,040 --> 00:04:09,420
‫Bien, vamos a compilar esto y de vuelta aquí en el editor, voy a abrir BP -- tanque y abrir el

63
00:04:09,420 --> 00:04:10,920
‫editor de planos completo.

64
00:04:10,920 --> 00:04:16,200
‫Y ahora puedo agregar este componente de salud aquí en el panel de componentes.

65
00:04:16,290 --> 00:04:20,130
‫Así que voy a hacer clic en Agregar y buscar Salud.

66
00:04:20,370 --> 00:04:22,350
‫Y aquí vemos salud.

67
00:04:22,530 --> 00:04:25,860
‫Ahora, lo llamamos componente de salud en C++.

68
00:04:25,860 --> 00:04:29,670
‫Y, de hecho, la ventana emergente muestra que se llama componente de salud.

69
00:04:29,670 --> 00:04:33,420
‫Así que quita ese componente cuando lo muestra aquí.

70
00:04:33,420 --> 00:04:38,220
‫Y es posible que haya notado que cuando busca componentes de malla estática o componentes de cápsula,

71
00:04:38,220 --> 00:04:40,890
‫tampoco ve aquí la palabra componente para esos.

72
00:04:40,890 --> 00:04:48,270
‫Haga clic en salud y ahora tenemos nuestro componente de salud y verá que en el componente de salud

73
00:04:48,270 --> 00:04:55,080
‫tenemos salud máxima y está configurado en 100 y no vemos salud porque no expusimos esa variable.

74
00:04:55,170 --> 00:05:02,430
‫Así que ahora el tanque BP tiene un componente de salud y decía que el tanque posee este componente de salud, el

75
00:05:02,430 --> 00:05:03,390
‫tanque BP.

76
00:05:03,860 --> 00:05:06,590
‫Es el propietario de este componente de salud.

77
00:05:06,620 --> 00:05:13,760
‫Vamos a compilar, guardar, cerrar y abrir la torreta de peones BP y abrir el editor de planos completo y también podemos agregar

78
00:05:13,760 --> 00:05:16,930
‫un componente de salud a la torreta del estanque.

79
00:05:16,940 --> 00:05:21,620
‫Así que hagamos clic en agregar componentes, busquemos salud y seleccionemos salud.

80
00:05:21,620 --> 00:05:25,490
‫Y ahora también tenemos un componente de salud en la torre.

81
00:05:25,670 --> 00:05:30,560
‫Así que voy a compilar y guardar estos cerrar y guardar todo.

82
00:05:30,590 --> 00:05:36,650
‫Así que ahora tenemos un componente de salud y mencionamos que nos gustaría tener un componente de salud

83
00:05:36,650 --> 00:05:38,740
‫para poder reutilizarlo con diferentes clases.

84
00:05:38,750 --> 00:05:44,330
‫Entonces, si tenemos un peón en el mundo, digamos, nuestra torre, tendrá su propio componente de salud y luego

85
00:05:44,330 --> 00:05:47,040
‫nuestro tanque puede tener su propio componente de salud.

86
00:05:47,060 --> 00:05:52,340
‫Ahora, cuando nuestro proyectil interactúa con cualquiera de estos, por ejemplo, cuando genera un evento de

87
00:05:52,340 --> 00:05:57,680
‫golpe, cuando golpea una de estas cosas, nuestros peones pueden activar alguna funcionalidad en el componente

88
00:05:57,680 --> 00:06:00,830
‫de salud y cambiar esos valores de salud.

89
00:06:00,830 --> 00:06:07,820
‫Poner nuestra funcionalidad de salud en un componente y luego agregar ese componente a una clase tiene algunas ventajas sobre

90
00:06:07,820 --> 00:06:13,760
‫la alternativa, que sería simplemente colocar la funcionalidad de salud en la clase de peón base, por

91
00:06:13,760 --> 00:06:17,520
‫ejemplo, y heredar eso en el tanque y la torre.

92
00:06:17,540 --> 00:06:25,280
‫Verá, esto nos permite mantener pequeñas nuestras clases de tanques y torres y solo tratar con la funcionalidad específica para

93
00:06:25,280 --> 00:06:26,420
‫esas clases.

94
00:06:26,420 --> 00:06:32,840
‫Mientras que el componente de salud se puede agregar a cualquier otro actor, como cosas que no actúan como tanques

95
00:06:32,840 --> 00:06:33,800
‫o torres.

96
00:06:33,800 --> 00:06:39,290
‫Podemos hacer un muro destruible, por ejemplo, que podría destruirse tan pronto como reciba suficiente

97
00:06:39,290 --> 00:06:39,950
‫daño.

98
00:06:39,950 --> 00:06:43,910
‫Entonces, hablemos un poco sobre cómo podemos hacer que esto suceda ahora.

99
00:06:43,910 --> 00:06:50,810
‫Unreal Engine ha incorporado la funcionalidad de daño y su sistema dañado es bastante sofisticado.

100
00:06:50,810 --> 00:06:58,490
‫Cualquier actor en nuestro juego hereda una serie de eventos de daño, uno de los cuales es recibir cualquier daño.

101
00:06:58,490 --> 00:07:03,440
‫Este es un delegado de multidifusión, al igual que en el hit del componente.

102
00:07:03,470 --> 00:07:08,360
‫Ahora vamos a agregar componentes de salud a nuestros peones y estos se basarán en nuestra U.

103
00:07:08,360 --> 00:07:09,860
‫Clase de componente de salud.

104
00:07:09,860 --> 00:07:16,550
‫Entonces, dado que sabemos que nuestros peones heredarán esto al recibir cualquier delegado de daño, entonces, si creamos nuestra

105
00:07:16,550 --> 00:07:22,640
‫propia función personalizada en la clase del componente de salud, podemos usar esta función como una devolución

106
00:07:22,640 --> 00:07:25,940
‫de llamada y vincularla al recibir cualquier daño. delegar.

107
00:07:25,940 --> 00:07:33,200
‫Entonces, cada vez que se genera un evento de daño, el delegado de tomar cualquier daño puede transmitir y se llamará

108
00:07:33,200 --> 00:07:37,460
‫a cualquier función vinculada a él en su lista de invocación.

109
00:07:37,460 --> 00:07:42,320
‫Entonces, la siguiente pregunta es ¿cómo hacemos que ese delegado transmita?

110
00:07:42,320 --> 00:07:45,080
‫Necesitamos una forma de generar un evento de daño.

111
00:07:45,080 --> 00:07:52,070
‫Bueno, hay una función en las estadísticas de tu juego que hará exactamente eso y se llama aplicar daño.

112
00:07:52,070 --> 00:07:58,550
‫Si usamos esta función estática de las estáticas de su juego para aplicar daño, aplicar daño requiere una

113
00:07:58,550 --> 00:08:02,180
‫serie de parámetros, incluido el actor que se está dañando.

114
00:08:02,180 --> 00:08:09,620
‫Entonces, si llamamos a aplicar daño, los actores en tomar cualquier delegado de daño serán despedidos y esa función de devolución de

115
00:08:09,620 --> 00:08:11,720
‫llamada será llamada en respuesta.

116
00:08:11,720 --> 00:08:15,830
‫Así que aplicar daño es lo que genera el evento de daño.

117
00:08:15,830 --> 00:08:19,520
‫Entonces, para configurar todo esto, tenemos tres pasos.

118
00:08:19,520 --> 00:08:25,760
‫Primero, cree una función de devolución de llamada y, dado que estará vinculada a cualquier daño, debe tener los

119
00:08:25,760 --> 00:08:31,550
‫parámetros de entrada correctos para que al recibir cualquier daño la llame y pase toda la información

120
00:08:31,550 --> 00:08:33,950
‫asociada sobre el evento de daño.

121
00:08:34,130 --> 00:08:37,970
‫El segundo paso es vincular esta devolución de llamada al delegado.

122
00:08:38,000 --> 00:08:43,850
‫Hemos visto cómo hacer esto con el delegado de hits en el componente usando la función dinámica add.

123
00:08:43,850 --> 00:08:45,530
‫Estaremos haciendo lo mismo aquí.

124
00:08:45,530 --> 00:08:52,000
‫Y el tercer paso es generar el evento de daño llamando a la función estática de tu juego, daño

125
00:08:52,010 --> 00:08:52,670
‫aplicado.

126
00:08:52,670 --> 00:08:56,210
‫Así que volvamos al código y comencemos a configurar esto.

127
00:08:56,600 --> 00:08:56,880
‫Bueno.

128
00:08:56,960 --> 00:09:01,910
‫Así que estamos aquí en el componente de salud y vamos a agregar una función de devolución de llamada.

129
00:09:01,910 --> 00:09:05,810
‫Ahora, esto puede ser nulo y podemos llamarlo como queramos.

130
00:09:05,960 --> 00:09:08,450
‫Voy a llamar a este daño recibido.

131
00:09:08,450 --> 00:09:14,870
‫Y debido a que estamos vinculando esto a un delegado, debe tener los parámetros de entrada correctos y apropiados

132
00:09:14,870 --> 00:09:16,280
‫para ese delegado.

133
00:09:16,310 --> 00:09:23,240
‫Ahora, para las funciones vinculadas al delegado de tomar cualquier daño, la lista de parámetros de entrada debe ser la siguiente.

134
00:09:23,240 --> 00:09:30,830
‫El primero es un puntero de actor llamado Actor dañado, y así es como suena.

135
00:09:30,830 --> 00:09:33,320
‫Es el actor que recibe el daño.

136
00:09:33,350 --> 00:09:38,480
‫El siguiente es un flotador llamado daño y esta es la cantidad de daño real.

137
00:09:38,510 --> 00:09:45,950
‫Ahora, a continuación, tenemos un indicador de tipo de daño de costo que se llama tipo de daño.

138
00:09:46,220 --> 00:09:52,430
‫Y la razón por la que tenemos este parámetro de entrada es porque Unreal Engine tiene el concepto de tipos de daño.

139
00:09:52,430 --> 00:09:59,090
‫Puede crear tipos de daños personalizados que tengan datos adicionales que le informen para hacer diferentes cosas según el tipo

140
00:09:59,090 --> 00:10:01,100
‫de daño que pueda tener.

141
00:10:01,100 --> 00:10:02,000
‫Daño por fuego.

142
00:10:02,000 --> 00:10:03,260
‫Daño por veneno.

143
00:10:03,320 --> 00:10:05,570
‫Daño explosivo y así sucesivamente.

144
00:10:05,570 --> 00:10:11,330
‫Y si desea implementar una funcionalidad personalizada para cada tipo de daño, debe implementarla en su

145
00:10:11,330 --> 00:10:13,430
‫propio tipo de daño personalizado.

146
00:10:13,460 --> 00:10:19,040
‫Ahora no estamos creando nuestro propio tipo de daño personalizado, pero debido a que estamos vinculando esta función

147
00:10:19,040 --> 00:10:22,940
‫al delegado de tomar cualquier daño, debe tener estos parámetros de entrada.

148
00:10:22,940 --> 00:10:24,380
‫Así que lo estamos incluyendo aquí.

149
00:10:24,410 --> 00:10:32,090
‫Ahora, el siguiente parámetro es un puntero de controlador A y se llama instigator y el Unreal Engine

150
00:10:32,090 --> 00:10:33,330
‫Damage System.

151
00:10:33,350 --> 00:10:38,050
‫Un instigador es el controlador responsable del daño.

152
00:10:38,060 --> 00:10:45,110
‫Entonces, si el daño fue causado en última instancia por un jugador que controlaba un peón, entonces el instigador es el

153
00:10:45,110 --> 00:10:46,820
‫controlador que posee ese peón.

154
00:10:46,850 --> 00:10:49,600
‫Ahora bien, no siempre tiene que haber un instigador.

155
00:10:49,610 --> 00:10:52,580
‫Si no hubiera ninguno, entonces esto simplemente sería nulo.

156
00:10:52,580 --> 00:10:59,510
‫Y ahora obtengo los garabatos rojos para poder declarar la clase de controlador A aquí entre paréntesis para

157
00:10:59,510 --> 00:11:00,410
‫la función.

158
00:11:00,440 --> 00:11:06,980
‫Ahora el último parámetro es un puntero de actor A y este se llama Damage Causer.

159
00:11:07,010 --> 00:11:10,370
‫Este es el actor real que causa el daño.

160
00:11:10,370 --> 00:11:13,220
‫Este sería el propio proyectil.

161
00:11:13,310 --> 00:11:20,670
‫Así que hemos declarado esta función de devolución de llamada de daño recibido y al igual que nuestra otra función de devolución de llamada en el golpe.

162
00:11:20,690 --> 00:11:22,970
‫Esto tiene que ser una función u.

163
00:11:22,970 --> 00:11:28,550
‫Así que le daremos la macro de función solo para asegurarnos de que funcione una vez que la vinculemos

164
00:11:28,550 --> 00:11:30,620
‫al delegado de tomar cualquier daño.

165
00:11:30,950 --> 00:11:35,680
‫Y ahora que lo hemos declarado, estamos listos para definirlo en el archivo CPP.

166
00:11:35,690 --> 00:11:38,540
‫Así que aquí en componentes de salud, CPP.

167
00:11:38,630 --> 00:11:45,530
‫Abajo en la parte inferior, voy a seguir adelante y darle a esto un cuerpo de función y calificar completamente la función con el

168
00:11:45,530 --> 00:11:46,970
‫nombre de la clase.

169
00:11:46,970 --> 00:11:49,400
‫Y ahora tenemos una devolución de llamada.

170
00:11:49,400 --> 00:11:52,400
‫Así que ahora necesitamos enlazar esto con el delegado.

171
00:11:52,400 --> 00:11:59,180
‫Pero el delegado no existe en el componente de salud, existe en los actores específicamente.

172
00:11:59,180 --> 00:12:05,970
‫Queremos vincular esto con el delegado de tomar cualquier daño en el peón que posee este componente.

173
00:12:05,990 --> 00:12:11,570
‫Entonces, ¿cómo accedemos al propietario de este componente para poder vincularnos a uno de sus delegados?

174
00:12:11,570 --> 00:12:17,270
‫Bueno, haríamos esto y comenzaríamos a jugar y la forma en que podemos acceder al propietario de un componente es a

175
00:12:17,270 --> 00:12:19,460
‫través de la función de propietario de git.

176
00:12:19,460 --> 00:12:23,530
‫Si pasa el cursor sobre esto, verá que devuelve un puntero de actor.

177
00:12:23,540 --> 00:12:27,620
‫Este es el puntero al actor que posee un componente.

178
00:12:27,620 --> 00:12:32,990
‫Los componentes pueden ser propiedad de peones, pueden ser propiedad de actores, por lo que devolverá el

179
00:12:32,990 --> 00:12:35,630
‫propietario en forma de puntero de actor.

180
00:12:35,810 --> 00:12:42,890
‫Así que tenemos nuestra función de devolución de llamada y nuestro segundo paso es vincularla al delegado para recibir cualquier daño que vaya

181
00:12:42,890 --> 00:12:46,640
‫a existir en el peón que posee el componente de salud.

182
00:12:46,790 --> 00:12:53,870
‫Entonces, dado que tiene experiencia en vincular devoluciones de llamada a delegados, este será su desafío en la clase de

183
00:12:53,870 --> 00:12:55,100
‫componente de salud.

184
00:12:55,100 --> 00:13:02,420
‫En Begin Play, vinculará el daño recibido al delegado de daño que existe en el

185
00:13:02,420 --> 00:13:04,190
‫propietario del componente.

186
00:13:04,190 --> 00:13:08,090
‫Entonces accederá a ese delegado a través de la función de obtener propietario.

187
00:13:08,090 --> 00:13:13,640
‫En otras palabras, vas a llamar a obtener propietario y desde ahí vas a acceder a tomar cualquier daño.

188
00:13:13,640 --> 00:13:20,660
‫Y luego, a partir de ahí, sabe cómo vincular las devoluciones de llamada a los delegados usando agregar dinámica si

189
00:13:20,660 --> 00:13:28,250
‫se queda atascado, mire cómo vinculamos la devolución de llamada al éxito al delegado del éxito del componente pausar el video y vincular

190
00:13:28,250 --> 00:13:31,790
‫el daño recibido al delegado de recibir cualquier daño ahora.

191
00:13:35,000 --> 00:13:35,360
‫Bueno.

192
00:13:35,360 --> 00:13:40,610
‫Así que estamos de vuelta aquí en el componente de salud y estamos listos para vincular nuestra función de devolución de llamada.

193
00:13:40,610 --> 00:13:47,390
‫Entonces aquí y comencemos a jugar, vamos a acceder al propietario usando la función de propietario de git y desde

194
00:13:47,390 --> 00:13:54,770
‫allí vamos a usar el operador de flecha para acceder a ese delegado llamado, tomar cualquier daño y recibir cualquier daño

195
00:13:54,770 --> 00:14:01,520
‫tiene la dinámica de agregar función y simplemente toma un objeto de usuario y un nombre de función.

196
00:14:01,520 --> 00:14:05,240
‫Ahora el objeto de usuario es el objeto para el que estamos vinculando la función.

197
00:14:05,240 --> 00:14:10,130
‫Es la clase que tiene la función de devolución de llamada y eso va a ser esto.

198
00:14:10,190 --> 00:14:14,420
‫Y finalmente tenemos nuestra función de devolución de llamada, que serás tú.

199
00:14:14,420 --> 00:14:16,790
‫Daño del componente de salud recibido.

200
00:14:16,790 --> 00:14:23,690
‫Ahora necesitamos recordar la dirección del operador porque en realidad toma una dirección de la función.

201
00:14:23,690 --> 00:14:31,460
‫Así que ahora el daño recibido está obligado a recibir cualquier daño y se agrega a la lista de invocación de ese delegado.

202
00:14:31,460 --> 00:14:37,790
‫Entonces, siempre que generemos eventos de daño, obtendremos una transmisión de este delegado que dará como resultado que

203
00:14:37,790 --> 00:14:40,970
‫se llame a la función de toma de daño.

204
00:14:41,570 --> 00:14:48,320
‫En resumen, creamos nuestro propio componente de salud y agregamos uno de estos al plano del tanque y

205
00:14:48,320 --> 00:14:50,540
‫al plano de la torre.

206
00:14:50,660 --> 00:14:58,130
‫Creamos una función de devolución de llamada llamada Damage Taken y la vinculamos al delegado on take any Damage.

207
00:14:58,130 --> 00:15:05,150
‫El siguiente paso es generar un evento de daño que resultará en la transmisión del delegado de tomar cualquier daño

208
00:15:05,150 --> 00:15:10,640
‫para que nuestra función de devolución de llamada de daños recibidos sea llamada en respuesta.

209
00:15:10,640 --> 00:15:13,520
‫Y lo configuraremos en el próximo video.

210
00:15:14,240 --> 00:15:15,140
‫Te veré pronto.