1
00:00:01,459 --> 00:00:20,379
En este vídeo vamos a hablar de algunos aspectos o algunos puntos de la tarea de la unidad 2 que suelen entrañar más dificultades o quizá ha llegado un cierto punto, pues puede suponer dificultades, lo cual es obvio en estas alturas del curso y bueno, porque tiene su complejidad.

2
00:00:20,379 --> 00:00:24,079
Bueno, para ubicar un poco voy a hablar

3
00:00:24,079 --> 00:00:31,359
Bueno, ya tenemos una nave que se va moviendo hacia arriba, hacia abajo

4
00:00:31,359 --> 00:00:37,840
Y como indica la tarea, claro, para que no se vaya escapando de los obstáculos

5
00:00:37,840 --> 00:00:40,520
Que pueden acabar con el juego

6
00:00:40,520 --> 00:00:44,759
Pues habrá que poner unos límites para que la nave no lo supere superiormente

7
00:00:44,759 --> 00:00:46,640
Ni tampoco atraviese el suelo

8
00:00:46,640 --> 00:01:06,040
En un primer momento cuando se persigue hacer algo en este sentido, es verdad que se suele pensar en, al limitar quizá lo que hay que hacer es decir, bueno, si supera voy a indicar a la nave y voy cambiando la posición.

9
00:01:06,040 --> 00:01:20,420
Bueno, pues decir que en cierto momento cuando superamos 23 en Y o al bajar hasta menos 2 en este caso, más o menos aproximadamente, pues habría que decir que no pueda continuar desde ese punto.

10
00:01:20,599 --> 00:01:28,599
Intentar algo relacionado con, si llegas a este punto, fijar el límite como un valor concreto.

11
00:01:28,599 --> 00:01:53,640
Pero hay otra forma de enfocarlo que en este caso es mejor, bueno, entiendo que ya más o menos sabemos hacer que la nave suba, baje y se gire, por lo que hemos visto en otros vídeos, pero en el propio método update puede haber un método que es el que uso para mover nave, que para que se ejecute el translate, tanto en vertical como en horizontal,

12
00:01:53,640 --> 00:02:07,579
Y eso dependerá de la variable en la que estamos guardando, fijaos en el nombre, las interacciones en estos getAxis, de subir y bajar, que hemos definido como axis,

13
00:02:08,219 --> 00:02:16,360
pues poner una condición de cuándo debe aplicarse este Translate, este movimiento en el espacio.

14
00:02:17,099 --> 00:02:35,800
Más que intentar definir si llega a tal altura, se tiene que quedar a tal altura, bueno, pues si llega a 50, se tiene que quedar en el 50, lo que se puede es, digamos, restringir que la condición, con una condición, ¿no?, pues que se ejecute directamente el movimiento.

15
00:02:35,800 --> 00:03:00,319
Y para eso, ¿qué se puede hacer? Pues en el update también, que en cada fotograma existan estos límites con los que, en un método que hemos creado posteriormente, definir en base a booleanas, una que sirve para limitar en el plano vertical, en la subida o bajada de la nave en el eje Y o en el horizontal.

16
00:03:00,319 --> 00:03:11,900
son dos variables que he creado en este código como globales, que empiezan siendo verdaderas, se encuentran en el límite horizontal o dentro del límite vertical,

17
00:03:12,360 --> 00:03:21,719
que hará que se mueva esa nave, que permitirá que la condición se ejecute para que se mueva la nave, pues lo que voy a hacer es fijar que estos in-limits,

18
00:03:21,719 --> 00:03:29,419
birds o horizontales, estos límites, estas booleanas que se han creado, pues vayan activándose o desactivándose según la condición.

19
00:03:29,419 --> 00:03:47,620
Y las condiciones, como ya vimos, pueden tener conectores para que en un solo if pueda haber una condición o varias o obligar, aunque aquí no nos interesa, obligar a que se aplique una u otra, tenga que darse una u otra y no las dos a la vez.

20
00:03:47,620 --> 00:03:57,240
Estos operadores se ven en la primera unidad, en la UT0, pero con estos dos ampersands se puede vincular varias condiciones.

21
00:03:57,500 --> 00:04:05,060
Una es obvia, que es decir, que el transform position en I, es decir, la posición en I del objeto que tiene este script, que es la propia nave,

22
00:04:05,560 --> 00:04:16,959
pues que si en I supera un límite vertical que hemos fijado, pues en ese caso, añadiendole que además se esté pulsando el axis,

23
00:04:16,959 --> 00:04:22,040
se esté dando la interacción superior a 0, que sería el eje positivo de subida,

24
00:04:22,680 --> 00:04:26,019
dentro del axis, recordemos que va entre el 1 y el menos 1,

25
00:04:26,120 --> 00:04:28,000
tiene un valor positivo y uno negativo.

26
00:04:28,139 --> 00:04:30,660
Bueno, pues en el vertical el positivo será la W,

27
00:04:30,899 --> 00:04:33,459
si estamos usando la combinación de teclas WAST.

28
00:04:35,399 --> 00:04:39,180
Aquí estaríamos diciendo que si supera cierto límite en el eje Y,

29
00:04:39,459 --> 00:04:40,879
que ahora vemos cómo se ha definido,

30
00:04:41,680 --> 00:04:45,560
y además estoy intentando subir porque este movimiento vertical,

31
00:04:45,560 --> 00:04:53,680
de esta interacción estoy intentando subir con la W, pues diré, oye, eres falso, y por tanto el movimiento no se aplicará.

32
00:04:54,319 --> 00:04:57,740
Básicamente el límite es que la nave se desactiva y no va hacia arriba.

33
00:04:58,600 --> 00:05:03,000
Lo mismo no tendría nada que ver si aquí cambiáramos la condición y pusiéramos menor,

34
00:05:03,100 --> 00:05:07,379
porque significaría que aunque haya sobrepasado ese límite por arriba, por eso esta indicación,

35
00:05:07,439 --> 00:05:12,500
además de mayúsculas, para que se vea claro, en este caso, si yo sigo dándole hacia arriba,

36
00:05:12,500 --> 00:05:18,579
aunque haya superado el límite, ¿vale? Pues ya la condición cambia completamente.

37
00:05:18,699 --> 00:05:27,120
Lo que quiero en este caso, igual que luego lo haré al revés, es si supero por arriba el límite e intento seguir subiendo, ¿vale?

38
00:05:27,439 --> 00:05:34,379
Bloquéame con este booleano el movimiento. Por el contrario, si esto no se cumple y lo que estoy es por debajo del límite vertical

39
00:05:34,379 --> 00:05:37,579
y además estoy intentando bajar, ¿vale? Ahora es el menos, también lo bloqueo.

40
00:05:37,579 --> 00:06:03,480
Tampoco quiero que la nave se desplace en el eje Y, sino, siempre que esté dentro de esos límites y no esté pulsando las teclas, pues sí permitirá el movimiento. Igual que si, aunque se haya, y a veces sucede, en ocasiones se puede superar un umbral, ¿vale? Una posición, porque por la propia inercia del movimiento, al subir mucho o al bajar, ¿vale? De la propia inercia se puede traspasar un punto que se había marcado como el límite, ¿vale?

41
00:06:03,480 --> 00:06:20,759
A lo mejor este limit bird down, que es esta variable global también, que se ha puesto 5 porque al ver la escena es el punto NGI que veo que es a partir del cual más abajo no quiero que baje la nave porque está el suelo, igual que aquí pongo un 30, ¿vale?

42
00:06:20,759 --> 00:06:35,600
Esto es escoger y ver la escena y probar si la nave, en qué momento yo quiero que sea el límite de subir o bajar.

43
00:06:35,600 --> 00:06:43,959
Si yo subo, subo, subo, quiero que el límite esté alrededor del 23 por arriba y del menos 2 por abajo.

44
00:06:43,959 --> 00:06:57,910
Esto se traduce en estos límites que estarán desplazados seguramente porque la propia nave también tiene su desplazamiento propio.

45
00:06:59,910 --> 00:07:12,470
Hemos puesto el 5. También es cierto que ya hay una traslación de 7 en el padre que se traslada al hijo y por eso el límite inferior es menos 2.

46
00:07:12,470 --> 00:07:15,670
que si le sumamos 7 es el 5 que hemos fijado

47
00:07:15,670 --> 00:07:19,649
y si subimos y le sumamos 7 es el 30

48
00:07:19,649 --> 00:07:22,649
que hay en este límite marcado

49
00:07:22,649 --> 00:07:25,069
os doy un truco, vale, aquí lo tenéis

50
00:07:25,069 --> 00:07:28,529
os doy un pequeño truco, esto sería ajustarlo a mano

51
00:07:28,529 --> 00:07:31,350
y ver que cuando, bueno, pues que si yo por ejemplo aquí le digo

52
00:07:31,350 --> 00:07:33,889
que sea menos 10, aunque yo vea un suelo

53
00:07:33,889 --> 00:07:37,410
pues, y reinicio, vale, guardo y reinicio

54
00:07:37,410 --> 00:07:41,910
aunque vea un suelo, pues vais a ver que la nave

55
00:07:41,910 --> 00:08:06,470
Bueno, tiene un límite físico que es el collider que cuenta, ¿vale? Pero bueno, que veis que si intento seguir bajando, bajará hasta que ya haya un punto que no baje, ¿vale? Que coincide con el 1, que si consideramos la posición, bueno, el 1 no, perdón, el menos 17, ¿vale? Que si le sumamos los 7 que hemos visto, pues daría ese menos 10.

56
00:08:06,470 --> 00:08:20,910
En ese caso es ir probando las posiciones hasta que tenga coherencia con los límites que hemos establecido. En este momento hemos determinado que es 5 para la altura inferior y 30 para la superior.

57
00:08:20,910 --> 00:08:34,110
Y con eso, lo mismo, aunque se haya superado el límite, si yo en cierto momento he superado ese límite, pero lo que quiero es bajar sin ningún problema, esto no se cumplirá la condición y el booleano será verdadero.

58
00:08:34,110 --> 00:08:49,470
Entonces, nuevamente, si volvemos al movimiento de la nave, siempre que esté en verdadero, en true, el booleano se cumplirá la condición para que haya esta traslación, este movimiento en el espacio

59
00:08:49,470 --> 00:08:51,509
Lo mismo pasa en el límite horizontal

60
00:08:51,509 --> 00:09:00,210
Aquí pongo un detalle, simplemente para que lo veáis, que es que aunque en una booleana no se ponga, esto ya se dijo en otro vídeo, no se ponga la condición de verdadero o falso

61
00:09:00,210 --> 00:09:15,370
Bueno, por defecto, si aparece la booleana aquí sin ningún comparativo posterior, se entiende que es si es verdadero. Es decir, si esta booleana guarda un verdadero. Un poco lo mismo que aquí, pero de forma más simple, más simplificada.

62
00:09:15,370 --> 00:09:23,450
Igual que si cuando vemos un if no hay llaves posteriormente, si solo hay una línea de instrucciones, solo hay un punto y coma, se va a ejecutar

63
00:09:23,450 --> 00:09:32,610
Es lo mismo básicamente que si aquí pusiéramos estas llaves, es exactamente lo mismo, solo que es otra forma simplificada de escribir lo mismo

64
00:09:32,610 --> 00:09:41,389
Entonces con estas limitaciones que se van poniendo es con lo que se puede ir delimitando que la nave se mueva o no

65
00:09:41,389 --> 00:09:56,889
Se puede hacer de más formas, pero probablemente esta sea una de las más simples para, bueno, pues eso, con algunas líneas dentro de este método, pues comprobar si está existiendo esa posibilidad de que se mueva la nave o no.

66
00:09:56,889 --> 00:10:25,509
En el eje horizontal, que vais a ver que lo que se hace es, como derecha-izquierda, digamos, si hemos centrado bien la nave, que era una de las cosas, si os acordáis, que se decía en la UT1 que la nave estuviera centrada para que la distancia también se cree centrada, etc., pues al final es simétrico lo que es el eje X, el desplazamiento horizontal, el máximo al que puede ir, porque aparece en el centro del suelo y llegará un punto que ya no me interesa que vaya hacia la derecha o hacia la izquierda.

67
00:10:25,509 --> 00:10:42,990
Y si lo calculamos desde el 0, pues es, por ejemplo, el más 20 o el menos 20, pueden ser el mismo valor solo con el signo cambiado, ¿no? Entonces, estas dos condiciones que veíamos aquí antes se pueden trasladar aquí simplemente con él, la misma variable, pues invirtiendo el valor, ¿no? Poniéndolo en negativo.

68
00:10:42,990 --> 00:10:45,590
luego, pues lo mismo, si quiero ir

69
00:10:45,590 --> 00:10:47,570
si estoy a la derecha y quiero

70
00:10:47,570 --> 00:10:49,450
seguir yendo a la derecha, más allá del límite

71
00:10:49,450 --> 00:10:51,789
pues, ojo, que no te va a dejar falso

72
00:10:51,789 --> 00:10:53,350
igual a la izquierda

73
00:10:53,350 --> 00:10:55,629
¿no? y lo bueno

74
00:10:55,629 --> 00:10:57,490
es que aquí con un único, igual que aquí

75
00:10:57,490 --> 00:10:59,490
hemos tenido que hacer el de dan o up, dos variables

76
00:10:59,490 --> 00:11:01,389
distintas para definir arriba y abajo

77
00:11:01,389 --> 00:11:03,470
porque no existe esa simetría

78
00:11:03,470 --> 00:11:05,309
con un mismo, una misma

79
00:11:05,309 --> 00:11:06,850
variable de

80
00:11:06,850 --> 00:11:09,210
un número, ¿no? un float o un int

81
00:11:09,210 --> 00:11:10,889
se puede indicar

82
00:11:10,889 --> 00:11:13,649
tanto el lado derecho como el izquierdo.

83
00:11:14,350 --> 00:11:18,990
Otro, ahora que empiezan los códigos a tener un poquito más de longitud,

84
00:11:19,590 --> 00:11:25,570
otro truco que se puede ver es si quiero ir a donde se ha declarado esta variable,

85
00:11:25,809 --> 00:11:28,330
porque me he olvidado de cuál es o porque quiero cambiar el valor,

86
00:11:28,750 --> 00:11:34,330
dándole al control, se pone la indicación en azul, está hipervínculo,

87
00:11:34,450 --> 00:11:38,210
al clicar nos lleva a donde está declarada, por si por ejemplo lo quisiéramos cambiar.

88
00:11:38,210 --> 00:11:47,450
Este 30 o este 40, como hemos visto, sirve de 40 a la derecha y menos 40 a la izquierda. Con un único valor, una única variable, se puede conseguir.

89
00:11:48,190 --> 00:11:58,750
Hay un aspecto, bueno, aparte de que tenga aquí preparados más métodos, etc., este check limits, que es con lo que voy aplicando las booleanas, realmente está mal planteado.

90
00:11:58,750 --> 00:12:12,710
Funciona, ¿vale? Está funcionando, pero fijaos que los límites que la booleana, que luego sirve para definir o para que la condición se dé de si la nave se mueve o no, se ejecuta realmente después de mover nave, ¿vale?

91
00:12:12,710 --> 00:12:20,909
Que es la que estoy viendo aquí, que hace efectivamente eso. ¿Vale? Esto también sirve para que hablemos, primero, de que el orden adecuado o más certero, ¿no?

92
00:12:20,909 --> 00:12:40,149
sería este, que primero establezca si esto es verdadero o falso y luego ya se haga el movimiento, pero también sirve porque aunque en ocasiones lo pongamos mal, implica que nuevamente si nos empeñamos en solo poner el límite como condición para que se dé o no una condición,

93
00:12:40,149 --> 00:12:42,470
si hemos comprobado después

94
00:12:42,470 --> 00:12:44,830
de cuando se está haciendo este método

95
00:12:44,830 --> 00:12:46,590
es decir, se ha movido la nave en fotograma

96
00:12:46,590 --> 00:12:48,750
antes en el fotograma, que la aplicación

97
00:12:48,750 --> 00:12:50,710
de este check limits, se pueden dar

98
00:12:50,710 --> 00:12:52,669
casos en los que, bueno, pues se haya

99
00:12:52,669 --> 00:12:54,190
traspasado el umbral en ese momento

100
00:12:54,190 --> 00:12:56,970
entonces, bueno, recordad que podéis

101
00:12:56,970 --> 00:12:58,370
concatenar o podéis

102
00:12:58,370 --> 00:13:00,730
excluir condiciones entre sí

103
00:13:00,730 --> 00:13:02,950
en un único if, ¿vale? y es muy interesante

104
00:13:02,950 --> 00:13:04,470
ir contando que

105
00:13:04,470 --> 00:13:06,889
las condiciones, pues, pueden ser

106
00:13:06,889 --> 00:13:08,190
pueden ser varias

107
00:13:08,190 --> 00:13:30,330
Luego, por otro lado, acerca de las corrutinas, otro de los aspectos importantes es que cuando se están instanciando estos pivotes, estos obstáculos, para empezar, como ya vimos, la nave no se tiene que desplazar en profundidad.

108
00:13:30,330 --> 00:13:50,509
En los endless runner, en esta tipología de juego, en esta categoría, normalmente lo que se mueven son los... el fondo, ¿no? Y el personaje es el que va a izquierda, derecha o salta, o se mueve hacia arriba o abajo, pero no es el que se desplaza en infinito. Esto puede darse de otras formas, pero es una forma común de que ocurra.

109
00:13:50,509 --> 00:14:13,370
Entonces es bastante frecuente que existan elementos que tengan que ir hacia cámara. Si nos fijamos, aquí tengo un instanciador, un código que instancia este prefab que tengo del obstáculo, de hecho es el mismo que se incluye como material de la tarea, es por si lo quisierais usar, y se van instanciando los distintos.

110
00:14:13,370 --> 00:14:30,470
Se crea un GameObject con el serial exfil al que vinculamos este obstáculo y posteriormente lo que se va a realizar es abrir o iniciar, empezar en el start, para que no se vayan iniciando distintas corrutinas, se empieza una corrutina llamada crear obstáculo.

111
00:14:30,470 --> 00:14:46,090
Recordemos que para definir, para declarar una corrutina se debe hacer con esta interfaz de tipo enumerator, que básicamente lo que más nos interesa es que tiene esta instrucción posteriormente del GIL y más instrucciones.

112
00:14:46,090 --> 00:15:14,990
Lo bueno de las corrutinas es que permite ir espaciando o ir provocando en diferido la ejecución del código. Es decir, dar pausas a que se ejecute el código. Igual que en el update está continuamente ejecutándose fotograma tras fotograma, en el enumerator al comenzar la corrutina empieza, como cualquier método, a leer lo que tiene en su interior, de arriba a abajo.

113
00:15:14,990 --> 00:15:38,570
¿Qué ocurre? Que llegado a un cierto punto con esta instrucción del yield return, y en el tema pone también que si quisiéramos que se ejecutara cada fotograma se podría poner como nulo, pero bueno, eso en ciertos momentos puede servir para que funcione como una especie de update paralelo, pero no aprovecha su potencialidad.

114
00:15:38,570 --> 00:15:53,870
Tenemos esta instrucción de newWaitForSeconds, que como argumento, dentro de sus paréntesis, podemos introducir, aquí he puesto intervalo, para hacer un cálculo de velocidad, que puede ser dos valores que quiero relacionar,

115
00:15:53,870 --> 00:16:01,929
Para que si el juego se va relacionando con la velocidad a la que se mueven los obstáculos y lo pongo en una variable que comparto con otros scripts,

116
00:16:01,929 --> 00:16:11,730
que también defina el intervalo de tiempo entre una instancia y la siguiente del obstáculo, pero aquí no olvidemos que dentro de un wait for seconds se puede poner cuatro.

117
00:16:11,730 --> 00:16:26,870
Es decir, un número que identifica el número de segundos, se expresan segundos, que va a tardar en detenerse en esta línea de la instrucción y continuar.

118
00:16:27,470 --> 00:16:37,250
¿Qué ocurre? Que normalmente estos enumerators, estas corrutinas, se suelen encerrar en bucles más que nada porque no nos suele interesar que se ejecute una vez y acabe,

119
00:16:37,250 --> 00:16:49,429
sino que vuelva a, después de pasado, en este caso, estos cuatro segundos, como while true es un bucle infinito, pero yo estoy deteniendo conscientemente, volverá al comienzo y seguirá ejecutándose.

120
00:16:49,429 --> 00:17:16,109
A la vez, más que a la vez, digamos, buscando el momento dentro de la ejecución de cada fotograma del update, por ejemplo, pero irá buscando el momento en el que pasados cuatro segundos vuelva a ejecutarse esto. Entonces, podemos ir marcando el tiempo que tarda el código en continuar, el código dentro de este fragmento en continuar dándose. Por eso se dan estas condiciones de while true para irlo deteniendo cada cierto tiempo.

121
00:17:16,109 --> 00:17:40,710
Entonces, al final los obstáculos es una instanciación, se crea un punto de instanciación del obstáculo que se coloca en el espacio y lo que se puede hacer, como vienen de profundidad, lo que es el eje Y y el eje Z, yo ya defino con relación a la nave, con el propio Nulo, con el propio GameObject vacío,

122
00:17:40,710 --> 00:17:47,549
se puede indicar a qué distancia y en qué altura se van a instanciar los pivotes

123
00:17:47,549 --> 00:17:50,970
porque no van a estar flotando, entonces como siempre van a estar posados en el suelo

124
00:17:50,970 --> 00:17:55,809
pues se puede definir que siempre lo haga desde la misma altura y desde la misma profundidad

125
00:17:55,809 --> 00:18:00,789
porque al final se van a estar desplazando, me da un poco igual en este caso que esté más alejado

126
00:18:00,789 --> 00:18:04,609
lo que sí que no me da igual como estáis viendo, porque si no el juego sería simplísimo

127
00:18:04,609 --> 00:18:11,450
es la posición en X en horizontal que tiene, ¿no?

128
00:18:11,450 --> 00:18:13,970
Para que tenga sentido que lo vayamos esquivando o no.

129
00:18:14,529 --> 00:18:17,309
Entonces, como sugiere el enunciado de la tarea,

130
00:18:17,529 --> 00:18:20,329
se puede usar unos operadores que son el de random range

131
00:18:20,329 --> 00:18:22,910
que sirve para aleatorizar valores, ¿vale?

132
00:18:23,329 --> 00:18:26,210
Cuando ponemos un random.range entre sus paréntesis

133
00:18:26,210 --> 00:18:31,289
podemos poner dos valores, uno mínimo y otro máximo.

134
00:18:31,509 --> 00:18:32,950
Bueno, si nos ponemos encima del range,

135
00:18:32,950 --> 00:18:45,190
Si os fijáis en la leindita que pone, el primer argumento será el valor mínimo, el segundo será el mayor máximo y entre esos se irán generando valores intermedios.

136
00:18:45,289 --> 00:18:54,130
Entre menos 40 o 40, esta variable que he declarado aquí e inicializado con este random rates irá guardando en su interior valores aleatorios.

137
00:18:54,130 --> 00:19:08,390
Lo irá haciendo cada vez que llegue a este punto. Entonces, cada vez que dé la vuelta, creará otro número aleatorio, que es el que luego usaremos como posición en X para que salga esa instancia del obstáculo.

138
00:19:08,390 --> 00:19:30,369
Si os fijáis, aquí se declara y además se irá reiniciando cada vez que se dé este bucle, cada 4 segundos en este caso, en el que habrá un balón randomX aleatorio entre estos valores y luego un vector nuevo que se crea que fijará, primero, que conserve la posición en Y y en Z del objeto.

139
00:19:30,369 --> 00:19:46,609
En este caso, como el script está aplicado a este punto de instanciación, cogerá las coordenadas que pongamos de altura en i, en este caso un 0, no queremos que se eleve, y en z, que se ha desplazado 200 en profundidad.

140
00:19:46,609 --> 00:20:07,049
Si yo lo alejo, los obstáculos en este caso se irán generando desde más lejos. Pero lo que va cambiando en cada iteración es la posición de X, porque está cogiendo el valor aleatorio que en cada vuelta se va generando.

141
00:20:07,049 --> 00:20:20,549
Una vez que tenemos eso, se instancia el obstáculo, que es el GameObject que se ha incluido, ese prefab del obstáculo, y lo que se indica como posición es precisamente este vector 3 que se va generando.

142
00:20:20,549 --> 00:20:50,529
Entonces, en cada vuelta decimos que se genere este prefab otra vez, ¿vale? Se generará infinitas veces en esta posición, que irá cambiando solo en el eje X y, bueno, como ya vimos también en una de las declaraciones del Instance 8, en una de las sobrecargas, si queremos poner un vector 3 como segundo valor para la posición y no es el transform de otro padre, etc., bueno, pues hay que incluir una rotación, que si no queremos que sea afectada, valdría con esta instrucción de quaternion.com.

143
00:20:50,549 --> 00:21:20,089
Que lo que hace es coger la rotación nula, que tampoco se ve afectada. Entonces, gracias a este enumerator, se va una y otra vez con esta pausa de 4 segundos en esta línea, pues se lanzará en el start y generará una primera instancia, esperará 4 segundos y al acabar el bucle dice, anda, si esto todavía se está cumpliendo, volvemos a hacerlos, instancia, esperará otros 4 segundos y así indefinidamente a menos que la paremos de alguna forma.

144
00:21:20,549 --> 00:21:27,009
Si queremos que este no sea un bucle infinito, que en esencia es lo que hace while true, se pueden poner bucles for, ¿vale?

145
00:21:27,009 --> 00:21:33,089
Para que tenga un número de iteraciones máxima o habría que poner alguna condición que pare la corrutina.

146
00:21:33,670 --> 00:21:38,630
Si ponemos un contador, una variable que cada vuelta vaya sumando uno, ¿vale?

147
00:21:39,089 --> 00:21:45,789
Pues llegará a un punto que aquí se podría poner también una condición si la variable tal es mayor de 10.

148
00:21:45,789 --> 00:21:58,910
Bueno, aquí he puesto variable, digo, estoy poniendo pseudocódigo, es decir, palabras para que nos entendamos, no están declaradas. Pues en este caso se puede decir que haga un stop corrutín o un stop all corrutín, si entonces lo que hace es parar esta corrutina.

149
00:21:58,910 --> 00:22:06,289
Bueno, pues con esto se puede conseguir que los obstáculos se estén instanciando indefinidamente

150
00:22:06,289 --> 00:22:10,869
Y con este tiempo de instanciación, con este tiempo que hay entre uno

151
00:22:10,869 --> 00:22:15,869
En este caso una ejecución del bucle y el siguiente

152
00:22:15,869 --> 00:22:20,109
Porque aquí se detiene en esta línea, dentro del enumerator

153
00:22:20,109 --> 00:22:23,930
El update, el start, el resto del código se seguirá ejecutando con lo que corresponde

154
00:22:23,930 --> 00:22:27,509
Pero dentro de este marco, de esta cápsula, de este enumerator

155
00:22:27,509 --> 00:22:47,529
Aquí se va a aplicar una pausa con el valor de este paréntesis. Luego, otra de las cuestiones es que cada obstáculo, cuando se instancia, los propios prefabs también pueden tener sus scripts aplicados, para que cuando sean instanciados ya puedan tener su código incluido.

156
00:22:48,210 --> 00:22:54,369
Si vamos a este, que cada vez que se instancia, vamos a verlo, uno de los obstáculos, ¿vale?

157
00:22:54,490 --> 00:22:58,450
Fijaos que ya tiene este movedor obstáculos, ¿vale?

158
00:22:58,490 --> 00:23:00,089
En todos, es el mismo, ¿vale?

159
00:23:00,089 --> 00:23:05,609
Cada uno de manera independiente, se van generando las instancias y tienen su código.

160
00:23:05,869 --> 00:23:07,329
Dentro de ese código, ¿vale?

161
00:23:07,349 --> 00:23:12,049
Es desde el que se podría, en este caso nos interesa más, voy a borrar el start que está vacío, ¿vale?

162
00:23:12,049 --> 00:23:18,930
con el update, añadir un transform translate que vaya en profundidad hacia la pantalla, hacia cámara, ¿vale?

163
00:23:18,930 --> 00:23:26,650
Por eso este vector 3 back, que básicamente es un 0, 0, y en el eje Z, un menos 1, que lo que hace es acercarse hacia cámara, ¿no?

164
00:23:26,650 --> 00:23:34,450
Viendo los gizmos que tenemos, pues si el Z es el valor de la profundidad, de alejarse, los valores positivos, los negativos,

165
00:23:34,450 --> 00:23:36,849
lo que harán es que se vaya acercando hacia la nave.

166
00:23:37,569 --> 00:23:43,990
Bueno, pues ahí con un translate que en cada update, en cada fotograma va moviendo de uno en uno

167
00:23:43,990 --> 00:23:49,890
y aparte cambiamos la velocidad que vayamos poniendo y equilibrando posteriormente con este DeltaTen

168
00:23:49,890 --> 00:23:55,710
como hemos hecho ya en otras muestras del translate, pues en cada fotograma se irá desplazando el obstáculo

169
00:23:55,710 --> 00:24:00,890
sin hacer nada más. El propio obstáculo tiene ya automáticamente, nada lo detiene en este caso,

170
00:24:00,890 --> 00:24:11,769
una traslación, un movimiento hacia la cámara. ¿Qué ocurre? Que cuando traspasa la cámara, podemos calcular un punto a partir del cual

171
00:24:11,769 --> 00:24:21,390
este GameObject que tiene el código y que es una script independiente en cada obstáculo, por tanto se irá aplicando a cada uno de los obstáculos

172
00:24:21,390 --> 00:24:29,829
que se han generado, que se han clonado, pues decimos que se destruya. Esto sobre todo se hace para que no se convierta esto en una sucesión

173
00:24:29,829 --> 00:24:49,869
Voy a ir al código previo y voy a decir que la estanciación sea más rápida para ver más ejemplos, que sea cada un segundo. Voy a guardar esto y lo que vamos a conseguir es que cuando cada pivote supere en Z el menos 10, pues se destruya.

174
00:24:49,869 --> 00:25:12,750
Haga ese ejercicio de destruirse. Por tanto, podemos estar viendo este pivote. Me voy a alejar un poco para ir viendo. Vamos viendo este pivote. Fijaos cómo traspasa la cámara que está justo detrás de la nave y cuando llega al menos uno, por ejemplo, vamos a poner este, fijaos en el Z, se van destruyendo.

175
00:25:12,750 --> 00:25:27,789
Aquí parece que están siempre los mismos, pero bueno, a la que se borra uno está apareciendo el siguiente, por eso es de continuo. Pero fijaos que se están desplazando en Z hasta que al superar menos 10, dentro de su código se indica, oye, destruyete, has llegado a menos 10, ya no te necesitamos.

176
00:25:27,789 --> 00:25:50,089
Si no se pusiera esta instrucción del destroy, aquí se irían sumando y sumando obstáculos que además se irían moviendo cada uno. Cuando llegara un punto ya que se han realizado tantas instancias de este obstáculo, que pudiera llegar a un número infinito de obstáculos, claro, la reproducción del juego y el procesamiento se va a ir viendo penalizada.

177
00:25:50,710 --> 00:25:55,789
Por ello, bueno, pues tiene que llegar un momento en el que se vayan eliminando las copias que ya no sean útiles.

178
00:25:56,109 --> 00:26:01,970
Aquí, por ejemplo, hay algo a observar, que es que fijaos que las copias, sobre todo cuando están a la derecha,

179
00:26:02,589 --> 00:26:05,490
desaparecen de forma muy abrupta y desaparece la sombra.

180
00:26:06,490 --> 00:26:11,130
Bueno, pues igual lo que nos interesa es que en vez de que sean Z, pues sean menos 40.

181
00:26:11,130 --> 00:26:19,369
Con esta declaración se puede indicar en qué punto van a desaparecer.

182
00:26:19,369 --> 00:26:36,930
Fijaos que está el obstáculo trasladándose y cuando llega a menos 40, ahora desplazado al menos 10, al menos 40, desaparece y se borra. Aquí desaparece porque ya no hay nada que leer en el inspector, pero de este modo vamos controlando el número de instancias que tenemos.

183
00:26:36,930 --> 00:26:41,029
Entiendo que con estas indicaciones

184
00:26:41,029 --> 00:26:44,109
Bueno, pues más o menos ya podéis ir superando

185
00:26:44,109 --> 00:26:47,089
La tarea, resolviéndola

186
00:26:47,089 --> 00:26:50,190
Si tenéis dudas o queréis que veamos algo en el foro

187
00:26:50,190 --> 00:26:53,950
Pues simplemente tenéis que indicarlo

188
00:26:53,950 --> 00:26:57,230
Así que nada, muchas gracias y ánimo con la tarea