1
00:00:02,740 --> 00:00:19,559
Pues nada, vamos a ver algunas apreciaciones sobre la tarea de la unidad cero, que creo que son importantes de ver en este momento del curso, justo antes de la entrega de la tarea.

2
00:00:19,559 --> 00:00:28,820
Bueno, simplemente para que sepáis un poco la lógica, por si hubiera dudas, tened en cuenta que a un mismo GameObject se le pueden aplicar distintos scripts

3
00:00:28,820 --> 00:00:37,799
Y, bueno, que coinciden con los que tenemos aquí en los proyectos, si os fijáis, se pueden ir activando y desactivando con estos ticks que tenemos aquí

4
00:00:37,799 --> 00:00:45,780
Es decir, se pueden dejar planteados y, bueno, pues sin borrarlos, decidiendo cuál se aplica y cuál no, ¿vale?

5
00:00:45,780 --> 00:01:02,460
Entonces, vamos a ir viendo un repaso de tres posibilidades, cada una con sus peculiaridades o sus posibilidades de cómo resolver lo planteado o lo requerido en la tarea cero, ¿vale? De la unidad cero.

6
00:01:02,460 --> 00:01:24,060
Voy a abrir este primero, que es el de diagrama versión simple. Simplemente cuando tenemos una clase, como esta que tenemos aquí, que recordad que tiene que coincidir su nombre del script con el de la clase, todo lo que se va a desarrollar en ese script tiene que estar dentro de estas llaves de la clase.

7
00:01:24,060 --> 00:01:46,379
Y anteriormente se encontrará la librería, los onamespaces, que van indicando al resto del código que lea ciertas órdenes o recoja o muestre sin error recolecciones de código en forma de otros métodos u otras clases que estamos invocando desde aquí.

8
00:01:46,379 --> 00:02:04,379
Desde el comienzo, cuando vayamos leyendo un enunciado o una tarea o tengamos que enfrentarnos a una tarea, es muy recomendable, que hasta ahora creo que no lo he mencionado, el uso de lo que se llama el pseudocódigo.

9
00:02:04,379 --> 00:02:21,120
El pseudocódigo se puede referir a varias cosas, pero principalmente a donde yo quiero llegar es que es muy interesante coger un papel y un boli y en ese papel y boli ir apuntando con lenguaje cotidiano, con el que expresamos todos los días, pues qué es lo que quiero hacer.

10
00:02:21,120 --> 00:02:43,360
Y en este caso, por ejemplo, lo que vamos a tener es una nave que va a tener varias vidas, tiene un escudo que va a tener 100, que en este caso, por ejemplo, le llama energía. Si hacemos ese pseudocódigo, que es un poco la lógica de funcionamiento de lo que queremos que haga nuestro código, luego nos va a ser mucho más fácil ir marcando qué es lo que necesitamos.

11
00:02:43,360 --> 00:02:49,800
Se podría hacer un papel aquí un poco, pues lo que se ha ido haciendo es eso mismo a través de los comentarios.

12
00:02:50,580 --> 00:02:55,259
Pero es muy interesante, que creo que nunca lo he dicho y no es como algo que se enfatiza mucho,

13
00:02:55,580 --> 00:03:04,439
pero pararse a sentar las bases de lo que se quiere conseguir antes de ponernos con el código y tener un poco claro qué se busca.

14
00:03:05,199 --> 00:03:10,020
Porque cuando estamos aquí con los scripts, todo se suele enrevesar un poco.

15
00:03:10,020 --> 00:03:30,740
Entonces, bueno, simplemente, y va a ser un poco común a los tres scripts que tenemos, pues hay ciertos ingredientes que vamos a tener que usar en forma de variables. Pues una, si estamos diciendo que va a haber vidas, habrá que poner vidas. Las vidas no van a tener parciales, no van a tener decimales, por tanto, no nos complicamos la vida y hacemos un int.

16
00:03:30,740 --> 00:03:38,020
La energía, los impactos, bueno, en principio aquí tampoco importa que tengan decimales

17
00:03:38,020 --> 00:03:39,319
Pero bueno, se pueden poner como Floats

18
00:03:39,319 --> 00:03:49,659
Luego una booleana que nos sirva para ir activándose cuando el juego está detectando que la partida se ha superado o no

19
00:03:49,659 --> 00:03:55,080
O mejor dicho, cuando la nave ha perdido todas las vidas y por tanto se ha acabado el juego

20
00:03:55,080 --> 00:03:57,120
Bueno, pues que se llama aquí Alive, de está vivo

21
00:03:57,120 --> 00:04:15,219
Y un mensaje que se puede emplear para irlo modificando esa variable con distintos strings que serán los que se irán mostrando luego en los debug logs o prints. Esto, evidentemente, siempre se puede hacer en un debug log o un print poner un string con el mensaje que queramos.

22
00:04:15,219 --> 00:04:29,639
Pero a veces nos puede ser más eficiente que en un mismo print, según en el punto en el que se llegue, el mensaje muestre sea uno u otro, por lo que podemos ir cambiando ese string en distintos puntos, ¿vale? Según las condiciones que se estén cumpliendo, ¿no?

23
00:04:29,639 --> 00:04:35,819
Entonces bueno, este repaso rápido es sobre todo para ver un poco la lógica de cómo resolver esto

24
00:04:35,819 --> 00:04:41,220
Es importante que cuando estamos generando estas variables

25
00:04:41,220 --> 00:04:45,560
Si no las hacemos públicas o se muestran en un serialize field

26
00:04:45,560 --> 00:04:49,480
Bueno, pues que las inicialicemos en el start

27
00:04:49,480 --> 00:04:52,639
Es decir, que cuando arranque el juego sea cuando coja los valores

28
00:04:52,639 --> 00:04:55,740
recordad, ya esto ya lo hemos visto

29
00:04:55,740 --> 00:04:57,220
que también se puede inicializar

30
00:04:57,220 --> 00:04:59,819
en el propio momento de la declaración

31
00:04:59,819 --> 00:05:01,519
de la variable, como variable global

32
00:05:01,519 --> 00:05:03,519
por ejemplo, el problema que hay

33
00:05:03,519 --> 00:05:05,480
si hacemos estas variables públicas

34
00:05:05,480 --> 00:05:07,579
o sería de isFile es que luego

35
00:05:07,579 --> 00:05:09,459
en el editor podremos cambiar el valor

36
00:05:09,459 --> 00:05:11,500
y sobre escribirá lo que

37
00:05:11,500 --> 00:05:13,420
tenemos aquí marcado, por tanto

38
00:05:13,420 --> 00:05:15,459
¿qué es lo mejor? en el momento de

39
00:05:15,459 --> 00:05:17,540
comenzar el juego, o de que arranque este script

40
00:05:17,540 --> 00:05:19,180
mejor dicho, pues decimos

41
00:05:19,180 --> 00:05:21,220
oye, estas variables tienen que valer tanto

42
00:05:21,220 --> 00:05:30,939
Y ya cuando arranque, a menos que haya otra instrucción posterior en el update, etcétera, que lo sobrescriba, pues eso es el valor que va a tener la variable.

43
00:05:32,860 --> 00:05:38,160
Por convención, estamos un poco viendo que la energía, la vida que tiene la nave es de 100 puntos.

44
00:05:38,879 --> 00:05:44,360
La nave, evidentemente, dentro de esta booleana como la estamos planteando, pues empieza viva.

45
00:05:44,959 --> 00:05:50,199
La nave está participando en el juego y hemos puesto, marcado que hay tres vidas.

46
00:05:50,199 --> 00:05:59,420
Aquí se marcan, digamos, los ingredientes principales de este juego que ahora vamos a poner en marcha.

47
00:06:00,079 --> 00:06:04,899
Luego, al comenzar el juego, esta línea se podría borrar, ¿vale?

48
00:06:04,980 --> 00:06:15,079
Pues todo lo que es la... voy a desampliar un poco para que se vea todo de un solo vistazo.

49
00:06:15,079 --> 00:06:38,160
A ver si con 120, ¿vale? Se ha generado, ya nosotros individualmente, aquí se ha generado un método que se llama impacto, que es donde cada vez que queramos que se dé esa condición de que hay un impacto contra la nave que restará vida, puntos, etc., bueno, pues está recogido dentro de este método.

50
00:06:38,160 --> 00:06:40,800
este método, bueno aquí se ha puesto que

51
00:06:40,800 --> 00:06:42,180
según se arranca el juego

52
00:06:42,180 --> 00:06:44,819
se ejecute, pero

53
00:06:44,819 --> 00:06:47,040
lo importante, dado que

54
00:06:47,040 --> 00:06:49,199
si no se ejecutaría todos los fotogramas

55
00:06:49,199 --> 00:06:50,720
es que claro, que se vaya

56
00:06:50,720 --> 00:06:52,360
ejecutando en distintos momentos

57
00:06:52,360 --> 00:06:54,579
si no ponemos una condición

58
00:06:54,579 --> 00:06:57,259
y pusiéramos que este impacto se ejecutara

59
00:06:57,259 --> 00:06:58,600
en el update sin más

60
00:06:58,600 --> 00:07:00,680
en cada fotograma se estaría ejecutando

61
00:07:00,680 --> 00:07:02,759
por tanto hay que pensar, y esto también

62
00:07:02,759 --> 00:07:04,480
pasará con las corrutinas y en el IE

63
00:07:04,480 --> 00:07:06,699
en el numerator, que hay que conseguir que estos

64
00:07:06,699 --> 00:07:11,899
bucles, update no deja de ser un bucle que se está ejecutando cada fotograma, que dentro

65
00:07:11,899 --> 00:07:20,220
de estos bucles haya algo que detenga una condición que haga que se cumpla o no, en

66
00:07:20,220 --> 00:07:25,459
este caso el método de esta operación de impacto. Veremos que en este caso, ahora que

67
00:07:25,459 --> 00:07:31,860
ya hemos visto ciertas interacciones, se puede hacer marcando que no pase nada, que no se

68
00:07:31,860 --> 00:07:36,500
ejecute el impacto hasta que no, en este caso, demos a la barra espaciadora, aparte se pone

69
00:07:36,500 --> 00:07:38,339
otra condición, recordad a este operador de

70
00:07:38,339 --> 00:07:40,579
conjunción de condiciones

71
00:07:40,579 --> 00:07:42,720
¿no? Bueno, pues la nave tiene que estar

72
00:07:42,720 --> 00:07:44,740
viva. ¿Esto por qué?

73
00:07:45,300 --> 00:07:46,240
Por ejemplo, diréis

74
00:07:46,240 --> 00:07:48,720
porque al final del juego cuando se agoten

75
00:07:48,720 --> 00:07:50,519
todas las vidas, ¿vale? La nave

76
00:07:50,519 --> 00:07:51,899
pasará a estar muerta

77
00:07:51,899 --> 00:07:54,759
pero el juego sigue reproduciéndose. ¿Qué ocurre?

78
00:07:55,199 --> 00:07:56,459
Que no querremos que se

79
00:07:56,459 --> 00:07:58,339
produzcan más impactos

80
00:07:58,339 --> 00:08:00,079
porque la nave ya está muerta

81
00:08:00,079 --> 00:08:02,399
aunque diéramos a la barra espaciadora no queremos

82
00:08:02,399 --> 00:08:04,540
que siga restando vida ni que haga nada en ese

83
00:08:04,540 --> 00:08:32,659
Por eso, con esta condición de viva, pues nos aseguramos que una vez la nave, al tener cero vidas, pase a estar muerta, entre comillas, ese booleano pase a ser falso, pues ya no se ejecutará, ¿vale? Pero esta lógica de interrumpir los bucles con condiciones es esencial, ¿vale? Y el uso de booleanas también para marcar estos semáforos de que algo se desarrolle o no, poner estos límites, también es muy importante tenerlo en cuenta.

84
00:08:33,379 --> 00:08:45,279
Una vez se da a esta barra espaciadora, se desarrolla lo que hay dentro de este impacto, que es donde está el intríngulis de las operaciones de lo que va a ocurrir dentro de este código.

85
00:08:45,980 --> 00:08:57,799
Impacto. Hay una forma de que este impacto, el daño que hace a la nave recogida en esta variable impacto, podría decirse que siempre fuera el mismo,

86
00:08:57,799 --> 00:09:21,080
Que fuera de 30 y se restara a las 100 y luego 30 y se restara a los 70, ¿vale? Pero tiene mucho más interés, y así lo vemos también, el uso de aleatoriedades, ¿no? Hay esta función dentro de la clase random, que es el range, que es un método que permite poner dos valores entre los que cada vez que se llame, ¿vale? Pues de un valor.

87
00:09:21,080 --> 00:09:47,799
Es decir, lo que estamos haciendo aquí es que el impacto, cada vez que le demos a este espacio y se ejecute, aquí al empezar, esta variable de impacto pase a valer un número aleatorio entre el 10 y el 80. Así conseguimos que esta resta de vida en cada pulsación, en cada iteración del impacto, pues valga distinto y así tiene un poquito más de riqueza el juego. No es siempre la misma lógica.

88
00:09:47,799 --> 00:10:03,379
Vale, las condiciones y esto es lo que os decía antes con el pseudocódigo, que está bien sentarse y decir, porque al final es trasladar a código lo que pensamos, las instrucciones, la lógica que tiene que seguir el juego y que estamos pensando.

89
00:10:03,379 --> 00:10:16,799
Hay que decir, bueno, si la nave tiene más vida del daño que hace el impacto, a la nave no hay que restarle una vida, o sí. Entonces, bueno, es donde vamos viendo estas condiciones.

90
00:10:17,679 --> 00:10:22,340
Por ejemplo, aquí, si el impacto es mayor que la energía, es decir, el escudo que tiene la nave,

91
00:10:23,320 --> 00:10:28,779
impepinablemente vamos a perder una vida. Se ha perdido toda la energía, todo el escudo, y perderemos una vida.

92
00:10:28,779 --> 00:10:32,580
Cuando se cumpla esta condición, restaremos una vida.

93
00:10:32,720 --> 00:10:38,279
Recordad este operador de menos menos, que va decreciendo lo que valga, por eso también es interesante,

94
00:10:38,840 --> 00:10:43,899
aunque podría ser un float, que sean números enteros, y si teníamos tres vidas,

95
00:10:43,899 --> 00:10:49,299
inmediatamente, si se diera la condición de que el impacto es mayor que la energía, se restaría una vida.

96
00:10:49,940 --> 00:10:55,539
De primera es esta condición, la primera vez que se ejecute el impacto, en este caso sería en el start,

97
00:10:56,019 --> 00:11:01,620
jamás se va a dar esta condición. ¿Por qué? Porque tenemos 100 de escudo y lo máximo que le va a quitar son 80.

98
00:11:01,740 --> 00:11:04,740
Por tanto, nunca va a morir en esa primera iteración.

99
00:11:04,879 --> 00:11:11,159
Entonces, lo que hará será, aunque luego tengamos otras condiciones dentro, saltará de esta llave a esta e irá al else.

100
00:11:11,159 --> 00:11:27,720
Si no, es decir, si la energía es mayor, el impacto es menor, mejor dicho, el impacto es menor que el escudo que se tiene, pues lo que hará será, lo lógico, que el escudo reste el daño que se le ha hecho.

101
00:11:27,720 --> 00:11:40,620
Y además, bueno, se puede hacer este mensaje, por ejemplo, de cuidado, solo te queda, se pone el resultado, el valor que tenga la variable energía en este momento, solo te queda 30 de escudo.

102
00:11:40,620 --> 00:11:52,779
Y finalmente, donde se imprime ese mensaje es a posteriori, en este debug log o print, que irá mostrando el mensaje conveniente según el que hemos guardado, según la condición que se haya dado, si os fijáis.

103
00:11:52,779 --> 00:12:10,159
¿Vale? Entonces, fijaos que en este caso, en vez de ir poniendo un debug log, aunque hay alguno más por aquí, con otra función, un debug log según cada condición, se puede hacer que cuando salga de todas las condiciones, muestra el mensaje relativo a la operación o a la condición que se haya cumplido.

104
00:12:10,159 --> 00:12:26,980
Y no ir plagando esto de debug logs, es verdad que se plaga de variables de mensaje, bueno, es otra forma de afrontarlo, pero al final ahí siempre, en cada ejecución de impacto, llega al final y dice, a ver, muéstrame ese mensaje, y es lo que va a mostrar.

105
00:12:26,980 --> 00:12:50,120
¿Vale? Si el impacto es mayor que la energía, mayor que el escudo, igual sería hasta mejor llamar a esta variable escudo, ¿vale? Algo que se puede hacer muy fácil, por cierto, que es que si os ponéis encima del nombre de una variable y le dais dos veces al control R, ¿vale? Vais a ver que se marca ese nombre y también todas las referencias que hay en ese script.

106
00:12:50,120 --> 00:13:11,179
Entonces podemos poner escudo y veis que se ha cambiado en todo el código y de esta forma, pues ahora pondrá escudo. Es un atajo muy útil. Dos veces con una selección de una palabra, del nombre de una variable, por ejemplo, con dos veces control R y nos permite cambiar el nombre y se cambiará en todas las referencias que haya en ese script.

107
00:13:11,179 --> 00:13:35,559
Vale, si el impacto es mayor que el escudo, el daño es mayor que el nivel de escudo que tiene la nave, se restará una vida. Si se resta esta vida y si las vidas en este punto no llegan a cero, lo que se va a mostrar será un mensaje de que has perdido una vida y te quedan tantas.

108
00:13:35,559 --> 00:13:50,720
Se indicaba también que cada vez que se pierde una vida y no se ha muerto, que es lo que pasará cuando se tenga cero vidas, se reproduzca un contador de las vidas que quedan.

109
00:13:50,720 --> 00:14:07,779
Para eso, para hacer consecuciones de instrucciones, bucles de instrucciones con una variable que determina cuándo empieza y cuándo acaba, lo mejor en este caso sería un bucle for.

110
00:14:07,779 --> 00:14:16,360
Con el bucle for lo bueno es que tenemos tres apartados que nos permiten definir cuándo se tiene que desarrollar ese bucle, ¿vale?

111
00:14:16,460 --> 00:14:25,100
El primero es declarar la condición o una variable que es el que va a servir para los otros dos aspectos.

112
00:14:25,539 --> 00:14:30,620
Entonces, declarando una variable, bueno, pues en este caso de tipo int puede ser de tipo float también, ¿vale?

113
00:14:30,620 --> 00:14:52,299
Si aquí en el bucle y esta n, ¿vale? Esta variable llamada n solo tendrá sentido dentro del bucle, ¿vale? Está siendo una variable local, ¿vale? Pues aquí lo igualamos que coja el valor de vidas que queden, ¿vale? Este bucle se irá desarrollando en estas llaves y no saldrá de él mientras n en cada iteración sea mayor que 0, ¿vale?

114
00:14:52,299 --> 00:15:06,679
Aquí, a diferencia de lo que veremos en otras ocasiones, se va a cumplir siempre. En el juego, siempre que lleguemos hasta aquí, por cómo están las condiciones, siempre va a haber más de una vida.

115
00:15:06,679 --> 00:15:30,820
Porque ya hemos escapado, digamos, con esta condición que no se cumpla. Lo que vamos a conseguir con esto es que tengamos dos, una o tres vidas, ¿vale? Va a empezar y va a decir, si ese número de vidas es mayor de cero, ¿vale? Pues me imprime, se estoy animando la vida y pondrá el valor que tiene ese n, ¿no? Pues si hemos perdido una vida de tres, pues pondrá dos.

116
00:15:31,480 --> 00:15:44,799
¿Qué ocurre? Que cuando acaba este bucle, esta última condición, lo que hará es, en este caso, restar, es lo que va a hacer al acabar el cambio, de cara a cuando vuelva a reproducirse el bucle.

117
00:15:45,019 --> 00:15:56,559
¿Qué vamos a hacer? Que el bucle va a reproducirse otra vez y si valía 2 la n en la primera vuelta, aquí pasará a valer 1, ¿vale? n. n, si os fijáis, no está en otro punto, solo sirve para el bucle.

118
00:15:56,559 --> 00:16:14,620
Y va a decir, vale, estoy animando la vida 1. Bajará otra vez el valor de n, se quedará en 0 y en ese caso, cuando vuelva a intentar ejecutar el bucle for, verá que la condición ya no se cumple. En este momento se sale del bucle y se continúa.

119
00:16:14,620 --> 00:16:42,740
Cuando hemos perdido una vida, escudo, que a través de los impactos habrá ido perdiendo valor, pues hay que resetearlo, hay que restablecer la energía, pues escudo volverá a pasar a valer 100 y la vida de nuevo volverá a valer 100 a falta de que volvamos a pulsar la barra espaciadora, existan impactos, impactos, impactos, hasta que después de varias lógicas las vidas llegan a ser en esta comprobación de cero.

120
00:16:42,740 --> 00:16:54,279
En ese momento, alive pasa a ser falso. Por tanto, esta condición ya para empezar acaba el juego de facto, en el sentido de que ya no se puede pulsar la barra espaciadora y se seguirá arrestando.

121
00:16:54,379 --> 00:17:02,299
Y aparte, bueno, pondrá un mensaje una última vez de has muerto, que es lo que se ha guardado en este message.

122
00:17:02,299 --> 00:17:23,740
Si os fijáis, esta puede que sea la forma más básica de cumplir lo pedido en el enunciado y si ejecutamos en la consola, ahora mismo vamos a ver todas estas operaciones a través de los prints o de backlogs de la consola,

123
00:17:23,740 --> 00:17:35,240
Pero esto evidentemente se podrá trasladar a la vida o comportamientos de un videojuego real.

124
00:17:35,619 --> 00:17:37,059
Entonces yo ahora mismo estoy aquí.

125
00:17:37,619 --> 00:17:44,880
Se ha lanzado ese primer impacto que se daba por defecto en el Start, sin ningún tipo de condición.

126
00:17:45,380 --> 00:17:48,200
Y ya nos ha restado como 52 aproximadamente.

127
00:17:48,859 --> 00:17:50,799
Si yo ahora voy pulsando la barra espaciadora.

128
00:17:50,799 --> 00:17:53,039
A ver que me haga caso.

129
00:17:53,039 --> 00:18:08,480
Ahí lo tenemos. He perdido una vida, ha hecho el contador y ha dicho, has perdido una vida, te quedan cero. Ahora mismo el escudo habrá vuelto a pasar a valer 100. Se podrían ir poniendo distintos mensajes o debug logs en cada punto.

130
00:18:08,480 --> 00:18:10,240
pues por ejemplo aquí después de esto poner

131
00:18:10,240 --> 00:18:11,579
debug log

132
00:18:11,579 --> 00:18:13,839
escudo restablecido a 100

133
00:18:13,839 --> 00:18:16,720
que nunca tengáis miedo a poner

134
00:18:16,720 --> 00:18:18,500
comprobaciones o mensajes

135
00:18:18,500 --> 00:18:20,819
en mitad del código

136
00:18:20,819 --> 00:18:22,900
es verdad que tener muchas

137
00:18:22,900 --> 00:18:24,940
a veces pueden suponer que salgan

138
00:18:24,940 --> 00:18:27,000
muchas de golpe y no enterarte pero siempre

139
00:18:27,000 --> 00:18:28,599
se pueden ir comentando

140
00:18:28,599 --> 00:18:31,019
rápidamente o comentando para ver

141
00:18:31,019 --> 00:18:33,019
las instrucciones

142
00:18:33,019 --> 00:18:34,839
bueno si continúo y le doy otra vez

143
00:18:34,839 --> 00:18:36,839
vale pues ahora me ha quitado del orden de

144
00:18:36,839 --> 00:18:39,460
63 de vida, le vuelvo a dar

145
00:18:39,460 --> 00:18:41,440
y me ha matado, ya solo queda una vida

146
00:18:41,440 --> 00:18:42,960
y me queda esa vida

147
00:18:42,960 --> 00:18:44,680
le vuelvo a dar, me ha quitado

148
00:18:44,680 --> 00:18:47,119
73, le vuelvo a dar

149
00:18:47,119 --> 00:18:49,000
ahora me ha quitado muy poquito, como 17

150
00:18:49,000 --> 00:18:50,619
y le vuelvo a dar y he muerto

151
00:18:50,619 --> 00:18:53,500
ahora, como el alive ha pasado a ser

152
00:18:53,500 --> 00:18:55,140
falso y ya no se cumple la condición de

153
00:18:55,140 --> 00:18:57,680
de pulsar la barra espaciadora

154
00:18:57,680 --> 00:18:59,720
que teníamos aquí, vale, esta segunda condición

155
00:18:59,720 --> 00:19:01,740
del if, no se cumple, por mucho

156
00:19:01,740 --> 00:19:03,099
que de yo a la barra espaciadora

157
00:19:03,099 --> 00:19:05,740
el juego ya se sigue

158
00:19:05,740 --> 00:19:11,420
reproduciendo podrían pasar más cosas o si hay otros scripts o si el juego tuviera otras otros

159
00:19:11,420 --> 00:19:17,920
comportamientos configurados otros otras acciones pero en este juego tal y como está hemos acabado

160
00:19:17,920 --> 00:19:26,759
ya sólo quedaría cerrar la partida y y hecho vale esta sería un poco la forma más rápida y

161
00:19:26,759 --> 00:19:34,880
digamos directa de conseguir esto que ocurre que por supuesto voy con otro script que en este caso

162
00:19:34,880 --> 00:19:54,880
Va a ser el de Vidas Nave. Voy a ir con el de Diagrama Corrutina, que es más intermedio. Voy a activar que el que se ejecute sea este script de Diagrama Corrutina. Guardo y guardo sobre todo para asegurarme de que todo está correcto.

163
00:19:54,880 --> 00:20:17,160
Correcto. En este segundo, al final es otra forma de enfocar un poco lo mismo, solo que la condición para que se ejecuten los distintos impactos ya no es pulsar una tecla, la barra espaciadora en el caso anterior, sino que se va a ir produciendo cada cierto tiempo.

164
00:20:17,160 --> 00:20:38,799
De manera automática, cada dos segundos, por ejemplo, se irá produciendo un nuevo impacto. Esto se consigue mediante las corrutinas, que como ya podréis haber visto en el tema 2, lo que abre es, no es del todo correcto esto que voy a decir, pero creo que lo más sencillo es, abre una línea de ejecución paralela que va en paralelo al update.

165
00:20:38,799 --> 00:20:58,000
¿Vale? Realmente sí que está deteniendo el flujo de trabajo en ciertos momentos y no es tanto un hilo paralelo, pero bueno, en cierto modo es lo que hace que de manera independiente o separada al update de cada fotograma podamos ir gestionando pausas y tiempos entre acciones.

166
00:20:58,000 --> 00:21:13,079
¿Vale? Nuevamente, se definen como variable global, bueno, pues el escudo, la vida de la nave, si está viva o muerta, ¿vale? Y bueno, incluso una variable para guardar el daño que guarda ese asteroide.

167
00:21:13,079 --> 00:21:33,160
Y aquí los mensajes, en vez de irse asignando en distintos momentos, que iba en el anterior caso, si recordáis, en la variable tipo string llamado message, se iba cambiando en distintos momentos, ya como variables globales se podrían definir ya los distintos mensajes.

168
00:21:33,160 --> 00:21:49,240
Tener ya todos preparados de antemano y ya simplemente con poner su nombre, cuando tengamos un debug log, se puede llamar. Por ejemplo, debug log, aviso reinicio. Cuando llamemos a eso, va a poner restablecido escudo, tus vidas son.

169
00:21:49,240 --> 00:22:05,339
Bueno, es otra forma de encararlo. Nuevamente, se puede hacer que el debug load tenga directamente, como sucede aquí, ya el string que nos convenga en este punto, pero nuevamente, según como sea el juego, la aplicación, etc., nos puede interesar una cosa u otra.

170
00:22:05,339 --> 00:22:08,599
damos los valores en el start

171
00:22:08,599 --> 00:22:09,759
como he comentado antes

172
00:22:09,759 --> 00:22:12,200
aunque aquí esté ya

173
00:22:12,200 --> 00:22:13,319
inicializado

174
00:22:13,319 --> 00:22:16,240
nada impide a que

175
00:22:16,240 --> 00:22:18,420
en el start, para asegurarnos que cuando se lance

176
00:22:18,420 --> 00:22:20,440
el script tenga los valores que queremos

177
00:22:20,440 --> 00:22:22,380
se vuelvan a poner, es un poco redundante

178
00:22:22,380 --> 00:22:24,539
es verdad que se podría eliminar

179
00:22:24,539 --> 00:22:26,619
esto y el resultado sería exactamente el mismo

180
00:22:26,619 --> 00:22:28,700
lo vamos a hacer por un poco de limpieza

181
00:22:28,700 --> 00:22:29,460
pero

182
00:22:29,460 --> 00:22:31,579
ahí está

183
00:22:31,579 --> 00:22:34,619
y cuando se arranca el juego

184
00:22:34,619 --> 00:23:04,079
e importante, lo pone aquí, se inicia una corrutina que se llama función impacto. Las corrutinas, como ya se explica en el tema, al final lo que hacen es lanzar un, entre comillas, método que hemos creado propios, pero que en vez de un void es de tipo enumerator, es una interfaz, es algo más avanzado, pero básicamente es un método que permite, sobre todo, usar instrucciones de este tipo para interrumpir la ejecución durante un tiempo, como hemos dicho.

185
00:23:04,619 --> 00:23:21,279
¿Vale? Importante, cuando se lanza una corrutina, pensad que tiene que ser en un momento concreto. Se pueden lanzar muchas corrutinas. ¿Qué ocurre? Que si este start corrutin estuviera en el update, ¿vale? Cada fotograma se iniciaría un nuevo hilo de ejecución.

186
00:23:21,279 --> 00:23:37,960
No, aquí lo que vamos a hacer es abrir una línea de ejecución que se irá parando cada cierto tiempo. Si vamos abriendo una en cada fotograma, de pronto puede haber cientos de líneas que se están ejecutando.

187
00:23:37,960 --> 00:23:50,859
Por tanto, es importante pensar que las corrutinas, en principio, y es lo que en mi cabeza tiene más lógica, es que se lanzan una sola vez y la corrutina empieza a operar y hace lo que tenga que hacer.

188
00:23:51,279 --> 00:24:00,079
Al final, lo que estamos haciendo es que al lanzar el start, de pronto se abre este enumerator y también se ejecuta lo que hay en su interior.

189
00:24:01,859 --> 00:24:08,759
Del mismo modo que hemos dicho antes con los for y con que en el update hay que parar la ejecución en ciertos momentos,

190
00:24:09,680 --> 00:24:19,700
en los enumerators normalmente lo que nos va a interesar siempre es establecer un bucle, ya sea mediante un for o un for infinito,

191
00:24:19,700 --> 00:24:31,700
Vamos a decir, que el tema viene representado de este modo, que si ponemos un for escrito así, significa que se va a reproducir sin ningún tipo de condición, fotograma tras fotograma.

192
00:24:32,440 --> 00:24:37,519
O se puede usar un while, con una condición que siempre se esté ejecutando.

193
00:24:37,519 --> 00:25:01,960
Que en este caso es que el estado de la nave esté vivo, ¿vale? Este true que tenemos aquí, bueno, pues mientras el juego se esté reproduciendo y la nave no haya muerto, pues nos interesa que siga habiendo impactos. Por tanto, es una condición que siempre se va a cumplir mientras el juego esté en marcha realmente, es decir, mientras el juego tenga sentido, porque la nave esté activa.

194
00:25:01,960 --> 00:25:17,059
¿Vale? Entonces, mientras se cumpla esta condición, antes de meterme en el detalle, pues va a reproducir esto, va a llegar a un punto en el que diga, oye, para aquí dos segundos y luego continúa y vuelve a hacer el bucle.

195
00:25:17,059 --> 00:25:34,400
¿Qué pasa? Que si no hacemos un bucle, básicamente el enumerator al iniciar la corrutina se va a reproducir y se va a acabar y ya está. Normalmente lo que queremos es que una operación se vaya repitiendo a lo largo del tiempo con estas pausas.

196
00:25:34,400 --> 00:26:00,500
Por eso es importante, por lo general, unir corrutina con un bucle de algún tipo. Normalmente un bucle incluso infinito. Ya lo iremos interrumpiendo o iremos haciendo pausas en distintos momentos, pero nos va a interesar que ese bucle se esté reproduciendo para que la acción se vaya realizando, porque la corrutina normalmente lo que nos interesa es eso, que tenga una periodicidad que podamos controlar.

197
00:26:00,500 --> 00:26:07,119
Una vez tenemos eso, pues igual que hemos hecho antes, se puede hacer una aleatoriedad del daño que va a hacer esta nave

198
00:26:07,119 --> 00:26:11,299
Y es un poco lo que se ha visto anteriormente

199
00:26:11,299 --> 00:26:15,119
Si el impacto del asteroide es mayor del escudo, se restará una vida

200
00:26:15,119 --> 00:26:17,640
Pondrá el aviso pertinente de has perdido una vida

201
00:26:17,640 --> 00:26:24,420
Y si al perder la vida hemos perdido, básicamente

202
00:26:24,420 --> 00:26:28,480
Aparte de poner un aviso de final de juego, pues la nave pasa a ser falsa

203
00:26:28,480 --> 00:26:37,319
Eso significa que cuando haga esta vuelta y vuelva aquí, la corrutina de facto ya no se va a ejecutar porque este bucle ya no se ejecuta.

204
00:26:37,700 --> 00:26:43,779
¿Qué ocurre? Que aunque no se ejecute el bucle, este enumerator está en marcha.

205
00:26:44,099 --> 00:26:47,720
Por tanto, también suele estar bien acompañarlo de un stop corrutín.

206
00:26:48,299 --> 00:26:53,740
El juego puede seguir continuando con otras acciones.

207
00:26:53,740 --> 00:26:59,859
y con esto lo que hacemos es cerrar esta línea de ejecución para que no siga corriendo y bueno

208
00:26:59,859 --> 00:27:05,200
pues optimizamos un poco que no que no siga algo ahí dando vueltas aunque ya no tenga nada en su

209
00:27:05,200 --> 00:27:10,779
interior pero bueno vale entonces cuando se acaba el juego cuando las vidas son igual a cero pues

210
00:27:11,839 --> 00:27:20,019
todo esto pasa a ser para indicar una partida acabada aunque se siga reproduciendo el juego

211
00:27:20,019 --> 00:27:37,240
Como antes sucedía, ya no se va a ejecutar el bucle ni va a haber, por tanto, resta de vidas, ¿vale? Pero si quedan más vidas en este punto, vamos a hacer nuevamente este contador de vidas que nos quedan, ¿vale?

212
00:27:37,240 --> 00:27:48,779
Bueno, aquí he hecho esta variable x, que lo que hace es recoger las vidas que tiene la nave después de haberle restado la que ha perdido, y siempre en cada vuelta va a irle bajando 1, una unidad.

213
00:27:49,299 --> 00:27:59,460
Mientras sea mayor que 0, pues hará el número de vueltas convenientes para mostrar el número de vidas que tiene, ¿vale?

214
00:27:59,460 --> 00:28:06,740
Bueno, pues hace ese contador, que es simplemente para probar cómo hace un for, y nuevamente resetea el escudo de la nave a 100, igual que sucedía antes.

215
00:28:07,240 --> 00:28:24,559
Pero por otro lado, sí, importante, fijaos que los if y else, que esto se podría optimizar seguramente más, pero es importante ver, me refiero a usar el if, usar distintas herramientas para que las condiciones no sean tan redundantes o sean más directas,

216
00:28:24,559 --> 00:28:42,180
Pero si tienes un if, aunque luego tengas ifs, es importante ir maquetando bien y haciendo la sangría bien de los distintos elementos para ir teniendo claro cuando esta condición no se da, aunque hay otros ifs o else, no se da y salta este else.

217
00:28:42,180 --> 00:28:56,400
Es importante que se pueden encadenar distintas condiciones una dentro de otra y a veces puede ser un lío si de pronto, por ejemplo, lo tenemos puesto así, porque empieza a ser, vale, pero ¿qué llave cierra cuál?

218
00:28:56,400 --> 00:29:14,400
Por eso es tan importante ir formateando. Hay una forma, ya que estamos en ello, de formatear el elemento de una manera automática que es yendo a...

219
00:29:14,400 --> 00:29:29,920
A ver, estaba en editar, dentro de avanzadas, editar avanzadas, hay uno para dar formato al documento.

220
00:29:29,920 --> 00:29:42,200
Y un poco analizando cómo se abren las llaves o no, hace un maquetado correcto, nos puede gustar más o no, pero suele ser muy limpio, de lo que tenemos escrito.

221
00:29:42,200 --> 00:30:06,440
Es un poco lo que habíamos hecho antes a mano a veces, que hay que ir dando espacios. Se puede ir haciendo con esa opción de editar avanzadas y dar formato al documento. Si queremos que solo lo haga de una sección, primero marcamos una selección y al darle a editar avanzadas, dar formato a la selección, solo se ocupará de formatear esa sección, esa parte.

222
00:30:06,440 --> 00:30:16,539
Vale, pues lo dicho, si el impacto de la nave es diferente a ser mayor al escudo de la nave

223
00:30:16,539 --> 00:30:22,359
Es decir, que con este L se está indicando que todo lo que sea que el escudo de la nave

224
00:30:22,359 --> 00:30:26,039
Que el impacto es menor que el escudo de la nave, por tanto no se resta vida

225
00:30:26,039 --> 00:30:28,539
Pues va a dar como resultado lo que hay aquí dentro

226
00:30:28,539 --> 00:30:34,079
Que el escudo de la nave se va a haber resentido, restando el valor del impacto

227
00:30:34,079 --> 00:31:00,460
Y bueno, pues aparte ponemos aquí un mensaje de te he restado tanto y te queda tanto de escudo, ¿vale? Y la clave, cuando ya ha comprobado todo eso, antes de que se vuelva a ejecutar otro impacto, ¿vale? Pues, pues bueno, pues tenemos aquí esta operación que es un poco larga de aprender, pero la corrutina es yield return new wait for seconds, ¿vale?

228
00:31:00,460 --> 00:31:13,400
Todo esto del tirón. Y dentro de las llaves se puede poner el número en segundos de lo que va a interrumpir esta ejecución hasta que se vuelva a reproducir.

229
00:31:13,579 --> 00:31:19,079
Irá aquí abajo, volverá arriba y dice, a ver, ¿el bucle se ejecuta? Sí, pues otra vez, otra vez, otra vez. Cada dos segundos.

230
00:31:19,799 --> 00:31:23,220
Aquí se puede poner el valor que se quiera, una variable que guarde un número.

231
00:31:23,220 --> 00:31:37,200
Pero fijaos que también se podría hacer algo interesante que es aleatorizar incluso el tiempo que permanece interrumpido.

232
00:31:37,400 --> 00:31:51,039
Si ponemos un random range que coge un valor entre 2 y 10, voy a exagerarlo más, la pausa la hará cada vez distinta y vamos aleatorizando el tiempo que tarda en volver a ejecutarse el bucle.

233
00:31:51,039 --> 00:32:06,500
Es decir, la pausa que conseguimos con la corrutina también sería aleatoria, también le podría dar un poco de variedad o riqueza al juego. Simplemente pensad que cuando tenéis un número, también puede ser un valor aleatorio.

234
00:32:06,500 --> 00:32:30,940
Vale, pues bueno, si vamos a, lo voy a poner de un segundo para que sea más rápido, si vamos ahora a nuestra aplicación y la lanzamos, pues vamos a ver que la consola ahora no va a ir esperando a que le demos a la barra espaciadora, sino que cada segundo va lanzando el siguiente impacto y se irán haciendo las operaciones de manera automática.

235
00:32:30,940 --> 00:32:57,059
A que ahora es un poco frío en el sentido de que el juego se va reproduciendo solo, pero bueno, nos puede interesar en cierto momento. No tenemos una interacción directa, pero también el juego se ha cumplido en el caso de que se ha ido restando el escudo de la nave, el valor de escudo, y bueno, se ha ido quitando vidas hasta que llega un punto en el que no quedan más vidas y se acaba la partida.

236
00:32:57,059 --> 00:33:20,240
Es otro enfoque distinto, pero que también permite cumplir con la tarea. Vamos con un tercer enfoque. Voy a ir rápido porque en el fondo es un poco la anterior modalidad en la que íbamos pulsando la barra espaciadora para ir lanzando un impacto.

237
00:33:20,240 --> 00:33:35,660
Se declaran las variables nuevamente, hay un booleano para indicar si se está vivo o no. Al principio se han generado también variables que guardan el valor máximo de escudo, etc.

238
00:33:35,660 --> 00:34:01,019
Para en vez de poner escudo actual al empezar 100, hay una variable que va a permitir que siempre que queramos resetear el escudo, podamos llamar a escudo máximo, que serán 100. Por eso aquí en el start, al comenzar el juego, no se está poniendo tiene que valer 100, sino que podemos cambiar en cualquier momento el escudo máximo, porque a lo mejor imaginaos que a lo largo de la partida se coge un power up y el escudo máximo pasa a ser de 300.

239
00:34:01,019 --> 00:34:28,780
Vale, pues hay una variable siempre que va a estar guardando ese valor y al que se podrá ir referenciando. Vale, pues es un poco lo mismo. Llegado cierto momento hay un update. Si pulsamos la barra espaciadora, aquí no estaría de más poner y vivo está en true, vale, para que siempre se cumpla. Aquí falta un paréntesis y aquí me sobra otro.

240
00:34:28,780 --> 00:34:32,539
cuando demos a la barra espaciadora

241
00:34:32,539 --> 00:34:34,260
se lanzará el método recibir impacto

242
00:34:34,260 --> 00:34:36,619
y aquí en vez de hacer

243
00:34:36,619 --> 00:34:39,440
que la variación del impacto

244
00:34:39,440 --> 00:34:41,440
cambie ya dentro del método

245
00:34:41,440 --> 00:34:43,260
o del enumerator

246
00:34:43,260 --> 00:34:45,579
que es lo que pasaba en estos momentos

247
00:34:45,579 --> 00:34:47,539
lo que vamos a hacer es

248
00:34:47,539 --> 00:34:48,920
que vamos a pasar

249
00:34:48,920 --> 00:34:51,139
esto simplemente para ver otra forma de hacerlo

250
00:34:51,139 --> 00:34:53,579
como parámetro del método

251
00:34:53,579 --> 00:34:54,960
este random range

252
00:34:54,960 --> 00:34:57,360
entonces cuando estemos

253
00:34:57,360 --> 00:35:02,440
declarando este recibir impacto, este método, vamos a pasar una variable

254
00:35:02,440 --> 00:35:06,099
de tipo float que se llama fuerza de impacto que luego podremos ir usando

255
00:35:06,099 --> 00:35:10,860
en su interior. Lo que valga la fuerza de impacto dependerá de lo que

256
00:35:10,860 --> 00:35:16,780
indiquemos aquí al invocarla. Aquí no tiene mucho sentido en el sentido

257
00:35:16,780 --> 00:35:22,440
de que solo se llama a esta variable, a este método, cuando damos a la

258
00:35:22,440 --> 00:35:25,400
barra espaciadora, pero podría ser otro juego que si en vez de dar a la

259
00:35:25,400 --> 00:35:37,300
barra espaciadora diéramos a la O, por decir algo, se lanzará este método, pero con idéntica lógica, pero cambiando lo que es este parámetro.

260
00:35:37,960 --> 00:35:49,199
Entonces, según si pulsáramos con la barra espaciadora o con la O, el impacto sería distinto, porque estamos llamando al método, pero justo la fuerza de impacto

261
00:35:49,199 --> 00:35:54,639
que estamos ejecutando cambiaría según cómo se ha invocado ese método, ¿vale?

262
00:35:54,760 --> 00:36:01,360
Luego tenemos otro en el update preparando con la tecla R que solo atenderá cuando ya hayamos perdido la partida

263
00:36:01,360 --> 00:36:04,699
y el vivo pasa a ser falso, que es el de reiniciar el juego.

264
00:36:05,099 --> 00:36:11,619
Aquí estamos metiendo un aspecto más allá que es que cuando ha muerto la nave tenemos la posibilidad de reiniciar

265
00:36:11,619 --> 00:36:15,599
para que todo vuelva a ser como era al comienzo, ¿vale? Lo vemos ahora después.

266
00:36:15,599 --> 00:36:28,139
Aquí en el update siempre está la posibilidad de dar al espacio a la R y si se cumple la otra condición, pues llamará al método recibir impacto o al método reiniciar juego, que lo tengo aquí.

267
00:36:28,900 --> 00:36:35,440
Entonces, de momento empezamos el juego y no queremos reiniciarlo, sino dar a la barra espaciadora y lanzamos.

268
00:36:36,679 --> 00:36:43,340
En esencia, lo que se encuentra aquí es exactamente igual, formulado con otro tipo de variables, quizá con otro orden.

269
00:36:43,340 --> 00:36:58,960
Al final las condiciones se pueden poner que primero sea que la fuerza del impacto sea menor que el escudo o al contrario, que sea mayor y el else entonces se invierte. Bueno, mientras las lógicas vayan teniendo sentido, pues todo es igual.

270
00:36:58,960 --> 00:37:19,719
Sí que aquí cuando ya después de los impactos se llega un momento en el que las vidas restantes pasan a ser cero y también esta condición de vivo pasa a ser falsa y por tanto al pulsar la R se puede reiniciar el juego, se lanza en este punto una corrutina que se llama mostrar mensaje.

271
00:37:19,719 --> 00:37:40,460
¿Por qué? Aquí lo que se buscaba, por ejemplo, es que cada dos segundos, ¿vale? Y fijaos que nuevamente se lanza esta corrutina, muestra el mensaje, se pone, bueno, este mensaje de inicio lanzado sirve, bueno, sí, que si no se ha lanzado nunca, ¿vale?

272
00:37:40,460 --> 00:37:55,820
Veis que es un semaforito que por defecto está en falso, pero cuando se lanza una primera vez, para que no se reinicie la corrutina varias veces, si está en falso, una vez se lanza, pasa a ser verdadero, se abre esta corrutina.

273
00:37:55,820 --> 00:38:07,119
¿Por qué? Porque si no puede ser que se iniciara la corrutina más ocasiones. Con esto conseguimos limitar que solo se lance una vez porque pasa a ser true. En este caso ya no se da la condición.

274
00:38:07,119 --> 00:38:30,260
Se crea un bucle que mientras se esté muerto, esté cada dos segundos lanzando el mensaje de juego terminado. Puedes presionar la R para reiniciar el juego. Esto es un mensaje simplemente para que cada dos segundos, una vez se ha perdido la partida, el jugador vea que ha perdido, pero que si da la R se puede reiniciar el juego.

275
00:38:30,260 --> 00:38:32,300
¿Vale? Cada dos segundos

276
00:38:32,300 --> 00:38:34,579
Saldrá este mensaje, una vez se ha perdido la partida

277
00:38:34,579 --> 00:38:36,199
Que se pulsa la R

278
00:38:36,199 --> 00:38:38,179
Pensad que aquí

279
00:38:38,179 --> 00:38:39,699
Tenemos planteado que

280
00:38:39,699 --> 00:38:42,440
Cuando pulsamos la R, y si estamos ya muertos

281
00:38:42,440 --> 00:38:44,179
Vivo es falso, se reinicia

282
00:38:44,179 --> 00:38:45,539
El juego, ¿vale?

283
00:38:46,380 --> 00:38:48,239
Reiniciar el juego, y esto es más avanzado

284
00:38:48,239 --> 00:38:49,980
Y es algo de lo que se hablará

285
00:38:49,980 --> 00:38:52,219
En la unidad 4, se puede

286
00:38:52,219 --> 00:38:53,420
Conseguir

287
00:38:53,420 --> 00:38:55,880
Reiniciando el nivel, ¿vale?

288
00:38:55,880 --> 00:38:57,940
Para eso, hay una biblioteca

289
00:38:57,940 --> 00:38:59,960
Que ya veréis, esto es más avanzado y voy a pasar ahora mismo

290
00:38:59,960 --> 00:39:03,800
de puntillas, una biblioteca que se puede añadir, que es este Unity Engine

291
00:39:03,800 --> 00:39:07,880
Scene Management, que es que

292
00:39:07,880 --> 00:39:11,420
podemos luego usar esta clase de Scene Manager y cargar

293
00:39:11,420 --> 00:39:15,940
una escena, en este caso la misma en la que estábamos, y resetea

294
00:39:15,940 --> 00:39:19,539
todo para que vuelva a empezar de nuevo. Al pulsar la R

295
00:39:19,539 --> 00:39:23,579
y con esta instrucción se reinicia el juego. Pero

296
00:39:23,579 --> 00:39:27,940
también lo que se podría hacer al reiniciar el juego es aquí poner

297
00:39:27,940 --> 00:39:31,079
nuevamente en vez de reiniciar todo

298
00:39:31,079 --> 00:39:33,300
entonces reiniciaría también el script

299
00:39:33,300 --> 00:39:35,840
reiniciaría el nivel por completo

300
00:39:35,840 --> 00:39:39,039
es volver a estos valores del comienzo

301
00:39:39,039 --> 00:39:40,539
que teníamos en el start

302
00:39:40,539 --> 00:39:44,059
copiarlos y volvería a empezar la partida

303
00:39:44,059 --> 00:39:44,639
como si nada

304
00:39:44,639 --> 00:39:48,440
porque el vivo volvería a ser true

305
00:39:48,440 --> 00:39:50,960
podríamos pulsar el espacio

306
00:39:50,960 --> 00:39:55,659
y volveríamos a estar exactamente como al comienzo

307
00:39:55,659 --> 00:39:57,500
y otra vez tendríamos las tres vidas

308
00:39:57,500 --> 00:40:14,719
100 de escudo, estamos jugando, estamos vivos. Por tanto, es otra forma de reiniciar. Al pulsar la R, reseteamos todo y ya podemos, otra vez, al dar a la barra espaciadora, empezar como otra partida, ¿vale?

309
00:40:14,719 --> 00:40:27,199
Además, como este bucle en este momento vivo pasaría a ser true, este enumerator, al ser falso, dejaría de reproducirse.

310
00:40:27,199 --> 00:40:51,679
¿Qué podríamos hacer aquí también? Cortar en este momento la corrutina que tenemos aquí abierta de mostrar mensaje para que no siga funcionando o que pueda entrar en conflicto si luego nuevamente al perder otra partida y volver a lanzar otra corrutina, pues que no haya conflicto con la que ya estaba iniciada.

311
00:40:51,679 --> 00:41:13,340
Las corrutinas, como podéis ver, se pueden lanzar tanto poniendo el nombre de la corrutina, el enumerator, como un string o llamándolo como si fuera un método. Es verdad que si se pone como método, aquí podemos pasar argumentos, parámetros y tiene más posibilidades, pero las dos deberían funcionar de manera correcta, tanto en el stop como en el start.

312
00:41:13,340 --> 00:41:22,699
Aunque haya puesto distintos, aquí se podrían poner un string o llamar a este enumerator del mismo modo que se llama a un método.

313
00:41:23,119 --> 00:41:32,539
Entonces, vamos a ponerlo a prueba. Limpio la consola y me ocupo de que el que vamos a usar es el de vidas nuevas, si no me equivoco.

314
00:41:32,539 --> 00:41:46,440
Pues sí, vidas nave, perdonad. Guardo, el script estaba guardado y ejecuto, ¿vale? Empieza el juego y yo cuando vaya dando, en este caso recordad que es al dar a la barra espaciadora de nuevo, resto vida.

315
00:41:46,440 --> 00:41:58,159
La nave ha chocado, ha recibido un impacto de 60 y ahora quedan 39 más, ¿vale? Bueno, el contador que habíamos hecho, voy a ir rápido, ¿vale? Va quitando vida, va quitando vidas hasta que perdemos.

316
00:41:58,159 --> 00:42:10,159
Y fijaos que en este momento, yo sin tocar nada, cada dos segundos me pone el mensaje Game Over, presione R para reiniciar el juego. Muy bien, pues le voy a dar ahora mismo a la R.

317
00:42:10,159 --> 00:42:28,860
Vale, se podría haber puesto un mensaje aquí al darle a la R y reiniciar el juego, un mensaje de ha reiniciado el juego. Se podría hacer, vale, para saber que al pulsar R, ahora tenemos la muestra de que no pasa nada porque no se está, se ha parado la corrutina porque no está volviendo a salir este mensaje.

318
00:42:28,860 --> 00:42:56,300
Pero nos falta un poco de input o de saber al jugador de que efectivamente se ha reiniciado, pero cuando vaya a dar otra vez a la barra espaciadora, veis que volvemos a tener el juego operativo, ¿vale? Vuelvo a jugar, a jugar, a jugar, a jugar hasta que me cargo todas las vidas y nuevamente se abre la corrutina que vuelve a reproducir este mensaje cada dos segundos de presión R para reiniciar el juego, ¿vale?

319
00:42:56,300 --> 00:43:14,780
Bueno, son distintas formas de afrontar esta tarea. Se podría hacer con más incluso. Probablemente hay algunos elementos, algunas construcciones de este código que se podrían refactorizar o formular de una mejor manera, pero funciona.

320
00:43:14,780 --> 00:43:29,340
Así que nada, espero que os sea útil. Estos códigos, una vez entregáis la tarea, los pondré en el aula virtual para que los chequeéis y nada, espero que os haya sido de utilidad.