﻿1
00:00:04,290 --> 00:00:05,650
‫Oye, bienvenido de nuevo.

2
00:00:05,670 --> 00:00:09,900
‫En este video, nos preocupamos por las condiciones de ganar y perder.

3
00:00:10,320 --> 00:00:14,520
‫Esta es una de las últimas cosas que vamos a manejar en este proyecto de juego.

4
00:00:14,550 --> 00:00:16,860
‫Ahora echemos un vistazo a nuestro plano de sección.

5
00:00:16,860 --> 00:00:23,430
‫Ahora, ya hemos marcado los primeros cinco elementos de nuestro plan de secciones, y los dos últimos son los

6
00:00:23,430 --> 00:00:26,580
‫efectos especiales y las condiciones para ganar y perder.

7
00:00:26,580 --> 00:00:32,250
‫Y me gustaría cambiar estos dos últimos y manejar las condiciones de ganar y perder solo

8
00:00:32,250 --> 00:00:39,300
‫porque esta es la última de nuestra lógica de programación de juego y los efectos especiales son cosméticos y más como

9
00:00:39,300 --> 00:00:42,420
‫toques finales para que podamos manejarlos al final.

10
00:00:42,420 --> 00:00:48,300
‫Entonces, en este video, vamos a crear una función de finalización del juego para que sepamos cuándo se ganó

11
00:00:48,300 --> 00:00:49,950
‫o se perdió el juego.

12
00:00:49,950 --> 00:00:55,410
‫Y para ganar el juego, necesitaremos contar la cantidad de torres en el mundo, porque una vez

13
00:00:55,410 --> 00:00:59,730
‫que hayamos destruido todas las torres, sabremos que hemos ganado el juego.

14
00:00:59,730 --> 00:01:05,670
‫Y si el tanque en sí se destruye, entonces podemos considerar que esa es la condición de pérdida.

15
00:01:05,670 --> 00:01:11,760
‫Así que estoy de regreso aquí en el modo de juego y lo primero que me gustaría hacer es crear otro evento implementable

16
00:01:11,760 --> 00:01:12,540
‫de plano.

17
00:01:12,570 --> 00:01:19,980
‫Tenemos esta función de inicio de juego, a la que podemos llamar desde C++, pero estamos implementando su lógica en el modo de

18
00:01:19,980 --> 00:01:20,520
‫juego.

19
00:01:20,520 --> 00:01:27,120
‫Blueprint Gracias a Blueprint Implementable Event, me gustaría crear otro de estos por perder el

20
00:01:27,120 --> 00:01:27,720
‫juego.

21
00:01:27,720 --> 00:01:31,530
‫Así que voy a crear una función nula llamada Game Over.

22
00:01:31,530 --> 00:01:37,530
‫Y para este, me gustaría tomar un parámetro de entrada booleano llamado B one game.

23
00:01:37,530 --> 00:01:43,020
‫Y, por supuesto, este será un evento implementable de blueprint porque lo único que me gustaría

24
00:01:43,020 --> 00:01:50,130
‫manejar con esta función es mostrar que hemos perdido o ganado el juego y que podemos hacer a partir de blueprints.

25
00:01:50,130 --> 00:01:52,410
‫Así que tenemos una función de fin de juego.

26
00:01:52,410 --> 00:01:55,350
‫Ahora necesitamos saber cuándo debemos llamar a esta función.

27
00:01:55,350 --> 00:02:00,450
‫Bueno, antes que nada, sabemos que podemos llamar a esta función cuando hemos perdido el juego, y

28
00:02:00,450 --> 00:02:02,550
‫eso será si el tanque ha muerto.

29
00:02:02,550 --> 00:02:10,050
‫Entonces, vayamos a nuestra función de actor muerto aquí en el modo de juego CP de tune tanks. Y vemos que si el

30
00:02:10,050 --> 00:02:15,840
‫actor muerto es el tanque, entonces estamos manejando la destrucción del tanque y configurando el estado habilitado

31
00:02:15,840 --> 00:02:16,680
‫en falso.

32
00:02:16,710 --> 00:02:25,020
‫Otra cosa que podemos hacer aquí es finalizar el juego simplemente llamando a game over y este booleano es un juego que podemos

33
00:02:25,020 --> 00:02:27,240
‫pasar como falso para esto.

34
00:02:27,240 --> 00:02:31,770
‫Entonces eso se encarga de perder el juego, al menos desde el lado de C++.

35
00:02:31,800 --> 00:02:34,770
‫Ahora necesitamos saber cuándo debemos ganar el juego.

36
00:02:34,800 --> 00:02:36,540
‫Ahora aquí murió un actor.

37
00:02:36,540 --> 00:02:43,050
‫Si el actor muerto puede ser arrojado a una torre, sabemos que acabamos de destruir una torre.

38
00:02:43,050 --> 00:02:49,740
‫Ahora, este sería el lugar perfecto para actualizar un conteo de torres o una variable de tipo entero que lleve

39
00:02:49,740 --> 00:02:53,220
‫un registro de cuántas torres hay actualmente en el mundo.

40
00:02:53,250 --> 00:02:53,580
‫Ahora.

41
00:02:53,580 --> 00:02:59,310
‫Para hacer eso, necesitamos una variable para realizar un seguimiento de la cantidad de torres, de modo que podamos

42
00:02:59,310 --> 00:03:02,250
‫agregar una variable privada aquí en el archivo H.

43
00:03:02,250 --> 00:03:03,960
‫Y me gustaría hacer eso aquí abajo.

44
00:03:03,960 --> 00:03:08,880
‫Así que voy a crear un INT 32 y lo llamaré torres de destino.

45
00:03:09,120 --> 00:03:15,840
‫Ahora podemos inicializar esto de inmediato a un valor de cero, pero debemos actualizarlo a medida que disminuye

46
00:03:15,840 --> 00:03:17,760
‫la cantidad de torres.

47
00:03:17,760 --> 00:03:22,350
‫Y también tenemos que ajustar esto al número de torres que hay en el mundo.

48
00:03:22,470 --> 00:03:28,170
‫Ahora podríamos codificar esto a cuatro, pero ¿qué sucede cuando comenzamos a agregar más torres a nuestros niveles?

49
00:03:28,170 --> 00:03:30,690
‫Bueno, entonces se vuelve un poco más complicado.

50
00:03:30,690 --> 00:03:35,580
‫Entonces, lo que me gustaría hacer en cambio es ver cuántas torres hay en el mundo.

51
00:03:35,610 --> 00:03:43,050
‫Ahora, podría crear una función para esto que devuelva 32 y esta función puede averiguar cuántas torres hay en

52
00:03:43,050 --> 00:03:45,810
‫el mundo y devolver el número.

53
00:03:45,810 --> 00:03:51,450
‫Así que voy a llamar a esta función, obtener un conteo de torre objetivo.

54
00:03:51,600 --> 00:03:55,650
‫Así que sigamos adelante y demos cuerpo a esta función en el archivo CP.

55
00:03:55,680 --> 00:04:02,130
‫Voy a ir hasta el final y crear el cuerpo de la función y no puedo olvidar poner el nombre

56
00:04:02,130 --> 00:04:05,040
‫de la clase antes del nombre de la función.

57
00:04:05,040 --> 00:04:12,270
‫Ahora esto va a devolver un extremo 32 y tenemos que decidir cómo vamos a averiguar cuántas

58
00:04:12,270 --> 00:04:13,170
‫torres hay.

59
00:04:13,200 --> 00:04:19,800
‫Ahora hay una función que existe en las estadísticas del juego llamada Obtener todos los actores de clase.

60
00:04:19,800 --> 00:04:21,300
‫Aquí está la documentación.

61
00:04:21,300 --> 00:04:25,770
‫Dice Encuentra todos los actores en el mundo de la clase especificada.

62
00:04:25,770 --> 00:04:28,890
‫Entonces necesitamos especificar una clase en particular.

63
00:04:28,920 --> 00:04:31,530
‫Ahora esta función tiene tres entradas.

64
00:04:31,530 --> 00:04:33,720
‫Primero es un objeto de contexto mundial.

65
00:04:33,720 --> 00:04:34,770
‫Ese es fácil.

66
00:04:34,770 --> 00:04:36,180
‫Sabemos cómo manejar eso.

67
00:04:36,180 --> 00:04:41,610
‫Pero a continuación tenemos una subclase PT de un actor y se llama Clase de actor.

68
00:04:41,610 --> 00:04:48,000
‫Ahora hemos visto que las funciones que requieren una subclase PT pueden aceptar una clase u como entrada y el tercer

69
00:04:48,000 --> 00:04:49,740
‫parámetro es una matriz T.

70
00:04:49,770 --> 00:04:56,940
‫Requiere una matriz t de punteros de actor y esto se pasa como una referencia y no es una

71
00:04:56,940 --> 00:05:03,680
‫referencia constante que parece sugerir que esta función podría cambiar este parámetro de entrada llamado acto.

72
00:05:03,730 --> 00:05:08,530
‫Aquí hay otra pista de que este es el caso, es que llama a los actores.

73
00:05:08,530 --> 00:05:15,820
‫Es un parámetro de salida, lo que significa que lo pasamos y luego, después de que se haya llamado a la función, tiene

74
00:05:15,820 --> 00:05:18,220
‫valores que la función le ha asignado.

75
00:05:18,220 --> 00:05:21,340
‫Entonces podemos pensar en ello como una especie de salida para la función.

76
00:05:21,340 --> 00:05:28,810
‫Ahora dice aquí abajo para los parámetros, la clase de actor es la clase de actor a buscar que debe especificarse o la

77
00:05:28,810 --> 00:05:30,640
‫matriz de resultados estará vacía.

78
00:05:30,640 --> 00:05:37,240
‫Queremos encontrar todas las torres y los actores son una matriz de salida de actores de la clase especificada.

79
00:05:37,240 --> 00:05:42,670
‫Entonces, una vez que hayamos llamado a esta función y la hayamos pasado en una matriz, cuando

80
00:05:42,670 --> 00:05:48,160
‫la función haya terminado, esa matriz contendrá punteros a todos los actores en el mundo de la clase especificada.

81
00:05:48,160 --> 00:05:51,880
‫Entonces sabemos que esta función requiere un objeto de contexto mundial.

82
00:05:51,880 --> 00:05:56,500
‫Ahora, si vamos a llamar a esto desde el modo de juego, podemos pasar esto a continuación.

83
00:05:56,500 --> 00:06:03,490
‫Necesitamos la subclase PT para especificar el actor A y sabemos que esto puede ser un nuevo puntero de clase.

84
00:06:03,490 --> 00:06:06,070
‫Ahora necesitamos especificar la clase a buscar.

85
00:06:06,070 --> 00:06:12,010
‫Si especificamos un actor, obtendremos una gran matriz llena de indicadores para cada actor en el mundo.

86
00:06:12,010 --> 00:06:13,810
‫Pero no necesitamos a todos los actores.

87
00:06:13,810 --> 00:06:21,070
‫Solo necesitamos las torres para poder usar una clase estática de torre que nos devolverá una nueva clase que representa

88
00:06:21,070 --> 00:06:23,290
‫la clase A Tower C++.

89
00:06:23,290 --> 00:06:26,770
‫Ahora el tercer parámetro es una matriz T de punteros de actor.

90
00:06:26,770 --> 00:06:33,760
‫Entonces, si creamos una variable local de tipo matriz T especificando el puntero de un actor en los paréntesis angulares,

91
00:06:33,760 --> 00:06:35,980
‫entonces podemos llamarlo estática del juego.

92
00:06:36,010 --> 00:06:41,620
‫Haga que todos los actores de la clase pasen esas tres entradas, y el resultado de esta acción será que

93
00:06:41,620 --> 00:06:45,970
‫nuestra matriz de torres debería contener punteros a todas las torres de nuestro mundo.

94
00:06:45,970 --> 00:06:52,840
‫Ahora, la bandeja es una buena clase de contenedor que puede contener una cantidad de elementos siempre que todos compartan el

95
00:06:52,840 --> 00:06:53,830
‫mismo tipo.

96
00:06:53,830 --> 00:07:01,690
‫Y esta clase tiene una gran cantidad de funciones que podemos usar al almacenar artículos en una bandeja.

97
00:07:01,720 --> 00:07:08,710
‫Ahora voy a desplazarme completamente hacia abajo y mostrarles esta función aquí llamada Num Short four number y dice

98
00:07:08,830 --> 00:07:12,310
‫Devuelve el número de elementos en la matriz.

99
00:07:12,310 --> 00:07:19,690
‫Entonces podemos usar esta función para obtener la cantidad de elementos en nuestra matriz una vez que tengamos todas las torres del

100
00:07:19,690 --> 00:07:20,380
‫mundo.

101
00:07:20,380 --> 00:07:26,080
‫Entonces, si llamamos al número de Tower, podemos usarlo como el valor de retorno para nuestra función.

102
00:07:26,080 --> 00:07:31,930
‫Y como vimos, establecemos nuestro valor de retorno para esta función a la que llamamos obtener el recuento de la torre de destino como

103
00:07:31,930 --> 00:07:35,980
‫un n 32, podemos devolver el número de elementos en la matriz de nuestra torre.

104
00:07:35,980 --> 00:07:41,230
‫Así que me gustaría desafiarlo a que implemente esta función de obtención de recuento de torres objetivo.

105
00:07:41,230 --> 00:07:44,710
‫Así que cree una matriz t local del actor tipo A.

106
00:07:44,710 --> 00:07:47,110
‫Puedes llamarlo torres o lo que quieras.

107
00:07:47,110 --> 00:07:52,930
‫Ahora use la función you game, play statics, obtenga todos los actores de la clase y asegúrese de pasar los

108
00:07:52,930 --> 00:07:54,220
‫parámetros de entrada correctos.

109
00:07:54,220 --> 00:08:00,310
‫Ahora, después de llamar a esta función, su bandeja contendrá punteros a todas las torres de nuestro

110
00:08:00,310 --> 00:08:06,850
‫mundo, por lo que simplemente puede devolver el número de torres usando esa función num que pertenece a la

111
00:08:06,850 --> 00:08:07,930
‫clase de bandeja.

112
00:08:07,930 --> 00:08:10,660
‫Así que adelante, pausa el video e implementa.

113
00:08:10,660 --> 00:08:12,640
‫Obtenga el recuento de torres objetivo ahora.

114
00:08:15,670 --> 00:08:16,000
‫Bueno.

115
00:08:16,000 --> 00:08:17,980
‫Así que aquí está el recuento de torres objetivo.

116
00:08:18,010 --> 00:08:24,250
‫Ahora, lo primero que voy a hacer es crear una matriz t local especificando un puntero de actor como el tipo

117
00:08:24,250 --> 00:08:26,590
‫de elemento que debe almacenar esta matriz.

118
00:08:26,590 --> 00:08:31,720
‫Y voy a llamar a esto torres ahora, necesito llamarlo estática de juego, así que necesito asegurarme de que

119
00:08:31,720 --> 00:08:33,100
‫ese encabezado esté incluido.

120
00:08:33,130 --> 00:08:38,830
‫Ahora veo que lo es porque lo estamos usando en algunas de nuestras otras funciones, pero es bueno hacer esa

121
00:08:38,830 --> 00:08:39,340
‫verificación.

122
00:08:39,370 --> 00:08:47,380
‫A continuación, puedo usar sus estadísticas de juego y llamaré a todos los actores de la clase.

123
00:08:47,410 --> 00:08:54,130
‫Ahora, la primera entrada es un objeto de contexto mundial que voy a pasar en esto y lo siguiente es la subclase de

124
00:08:54,130 --> 00:08:55,990
‫representación de la clase de actor.

125
00:08:55,990 --> 00:09:03,430
‫Y mencioné que podemos usar una clase estática de torre que devolverá una clase U que representa la clase

126
00:09:03,430 --> 00:09:04,270
‫de torre.

127
00:09:04,300 --> 00:09:09,190
‫Ahora, de nuevo, es una buena idea asegurarse de que estamos incluyendo torres, que es lo que estamos haciendo.

128
00:09:09,220 --> 00:09:14,740
‫Ahora, el tercer y último parámetro va a ser la bandeja y podemos pasar en torres.

129
00:09:14,740 --> 00:09:21,340
‫Entonces, una vez que se haya llamado a esta función, las torres ahora contendrán punteros a todas las torres del

130
00:09:21,340 --> 00:09:21,880
‫mundo.

131
00:09:21,880 --> 00:09:28,000
‫De hecho, si existen objetos de una clase que deriva de torres, también los obtendríamos.

132
00:09:28,000 --> 00:09:33,780
‫Entonces, dado que tenemos una matriz de torres, simplemente podemos devolver la cantidad de elementos en esa matriz.

133
00:09:33,790 --> 00:09:40,660
‫Así que voy a usar una declaración de retorno y usaré el número de puntos de las torres y ahora tenemos un recuento de torres de destino.

134
00:09:40,660 --> 00:09:41,740
‫Así que esto es genial.

135
00:09:41,740 --> 00:09:48,220
‫Podemos usar esto para inicializar nuestro conteo de torres, que llamamos torres objetivo y podemos hacerlo cuando comenzamos

136
00:09:48,220 --> 00:09:49,090
‫el juego.

137
00:09:49,090 --> 00:09:51,780
‫Así que voy a colocar eso aquí y manejar el inicio del juego.

138
00:09:51,790 --> 00:09:54,400
‫De hecho, me gustaría que sea lo primero que hagamos.

139
00:09:54,400 --> 00:10:02,530
‫Así que voy a tomar las torres de destino y establecerlas igual al valor de retorno de obtener el recuento de torres de destino.

140
00:10:02,560 --> 00:10:07,240
‫Ahora las torres objetivo deben inicializarse con el número de torres en nuestro mundo.

141
00:10:07,240 --> 00:10:13,120
‫Así que esto es genial, pero necesitamos actualizar este conteo cada vez que muere una torre, lo que significa

142
00:10:13,120 --> 00:10:16,000
‫que debemos entrar en nuestra función de actor muerto.

143
00:10:16,000 --> 00:10:22,660
‫Y aquí, si lanzamos un actor muerto a una torre destruida, luego de manejar la destrucción, debemos

144
00:10:22,660 --> 00:10:30,430
‫actualizar nuestra variable de torres de destino para que podamos decir torres de destino y podamos usar el operador de decremento.

145
00:10:30,430 --> 00:10:35,560
‫Podemos usar el operador de decremento posterior o el operador de predicamentos.

146
00:10:35,560 --> 00:10:41,800
‫Ambos darán como resultado la misma acción que es tomar torres objetivo y restarle una.

147
00:10:41,800 --> 00:10:48,220
‫Ahora, tan pronto como hayamos restado uno de las torres objetivo, ahora debemos verificar si las Torres objetivo

148
00:10:48,220 --> 00:10:49,660
‫han llegado a cero.

149
00:10:49,660 --> 00:10:55,150
‫Así que voy a colocar una verificación de si aquí para ver si las torres de destino han llegado a cero.

150
00:10:55,780 --> 00:11:02,380
‫Ahora, tan pronto como lo haga, sabemos que el juego debe terminar, por lo que podemos llamar a la

151
00:11:02,710 --> 00:11:10,660
‫función de fin del juego pasando en un juego 4b1 verdadero, ya que hemos destruido todas las torres y podemos considerar esto como una victoria.

152
00:11:10,660 --> 00:11:13,180
‫Ahora sigamos adelante y compilemos nuestro código.

153
00:11:13,180 --> 00:11:18,670
‫Ahora, de vuelta aquí en el editor, lo que me gustaría hacer antes de terminar este video es ir a nuestro modelo de

154
00:11:18,670 --> 00:11:19,420
‫modo de juego.

155
00:11:19,420 --> 00:11:21,040
‫Así que aquí está la melodía del pitido.

156
00:11:21,040 --> 00:11:24,400
‫Gracias modo de juego y tenemos este juego de inicio de evento.

157
00:11:24,400 --> 00:11:29,650
‫Y lo que estamos haciendo es crear nuestro widget de inicio de juego, agregándolo a la ventana gráfica para que podamos ver el

158
00:11:29,650 --> 00:11:31,780
‫temporizador de cuenta regresiva de inicio de juego.

159
00:11:31,780 --> 00:11:39,190
‫Entonces sabemos que se está llamando al inicio del juego, pero también necesitamos implementar nuestro evento implementable de juego sobre

160
00:11:39,190 --> 00:11:39,820
‫plano.

161
00:11:39,820 --> 00:11:47,260
‫Así que voy a hacer clic con el botón derecho y escribir game over y aquí está nuestro evento, game over y mira esto.

162
00:11:47,290 --> 00:11:50,860
‫Observe que tenemos este juego y es un booleano.

163
00:11:50,860 --> 00:11:57,220
‫Entonces, cuando llamamos a esta función desde C++, estamos pasando un valor booleano para B un juego.

164
00:11:57,220 --> 00:12:04,270
‫El nodo de evento blueprint elimina esa B minúscula y coloca un espacio entre uno y el juego como una especie de

165
00:12:04,270 --> 00:12:05,440
‫cortesía para nosotros.

166
00:12:05,440 --> 00:12:10,150
‫Ahora vamos a crear algunos widgets para que podamos ver cuándo ganamos o perdimos el juego, pero eso lo

167
00:12:10,150 --> 00:12:11,650
‫haremos en un video futuro.

168
00:12:11,650 --> 00:12:17,770
‫Por ahora, solo quiero confirmar que esto se está llamando y llamando correctamente para poder hacerlo con un nodo de

169
00:12:17,770 --> 00:12:22,180
‫cadena de impresión y podemos imprimir el valor en función de este valor booleano.

170
00:12:22,180 --> 00:12:29,080
‫Si hago clic y arrastro este booleano directamente a la entrada de cadena, veremos que hay una conversión de

171
00:12:29,080 --> 00:12:30,280
‫booleano a cadena.

172
00:12:30,280 --> 00:12:37,420
‫Este es otro nodo de conversión conveniente que convertirá un valor booleano en una cadena para nosotros, y su funcionalidad

173
00:12:37,420 --> 00:12:43,690
‫es tal que convertirá la palabra verdadero o falso en función del valor de verdad del valor

174
00:12:43,690 --> 00:12:44,350
‫booleano.

175
00:12:44,710 --> 00:12:46,120
‫Entonces, ¿por qué no probamos esto?

176
00:12:46,120 --> 00:12:48,040
‫Voy a compilar y darle al play.

177
00:12:49,400 --> 00:12:52,570
‫Muy bien, ahora estoy listo para tratar de ganar el juego.

178
00:12:52,580 --> 00:12:55,340
‫Espero no perder antes de poder hacerlo.

179
00:12:55,430 --> 00:13:01,430
‫Y perdí el juego y puedes ver falso impreso en la parte superior izquierda de la pantalla.

180
00:13:01,430 --> 00:13:08,570
‫Entonces, ahora sabemos que perder el juego da como resultado que el evento game over sea llamado y se pase falso, debemos

181
00:13:08,570 --> 00:13:12,050
‫asegurarnos de que se pase verdadero cuando ganemos el juego.

182
00:13:12,050 --> 00:13:14,900
‫Así que tratemos de matar todas las torretas.

183
00:13:15,380 --> 00:13:18,020
‫Así que realmente necesito tratar de no recibir un golpe.

184
00:13:18,020 --> 00:13:19,250
‫Oh, ya me golpearon.

185
00:13:19,910 --> 00:13:21,560
‫Esto es bastante desafiante.

186
00:13:22,840 --> 00:13:24,820
‫Y ahí vamos.

187
00:13:24,820 --> 00:13:28,720
‫Y verdadero está impreso en la parte superior izquierda de la pantalla.

188
00:13:28,750 --> 00:13:31,600
‫Solo aparece durante unos segundos, por lo que es posible que te lo hayas perdido.

189
00:13:31,630 --> 00:13:32,350
‫Ok genial.

190
00:13:32,350 --> 00:13:35,050
‫Así que ahora tenemos condiciones para ganar y para perder.

191
00:13:35,080 --> 00:13:41,380
‫El siguiente paso es mostrar esto en forma de un widget en la pantalla para que no dependamos del nodo

192
00:13:41,380 --> 00:13:42,850
‫de cadena de impresión.

193
00:13:42,880 --> 00:13:48,010
‫Entonces, en resumen, ahora tenemos condiciones para ganar y perder, y solo hay algunas cosas que

194
00:13:48,010 --> 00:13:53,890
‫debemos hacer para pulir esto, como crear widgets que informen al jugador que ha ganado o perdido el juego.

195
00:13:53,890 --> 00:13:58,900
‫También contamos el número de torres usando una bandeja y la función estática del juego.

196
00:13:58,930 --> 00:14:00,600
‫Consigue todos los actores de la clase.

197
00:14:00,610 --> 00:14:01,270
‫Gran trabajo.

198
00:14:01,270 --> 00:14:03,370
‫Este juego realmente está avanzando.

199
00:14:03,370 --> 00:14:09,220
‫En el próximo video, crearemos esos widgets y luego estaremos listos para comenzar a agregar efectos especiales

200
00:14:09,220 --> 00:14:10,840
‫y pulir nuestro juego.

201
00:14:10,870 --> 00:14:12,520
‫Te veré en el próximo video.

