Tutoría 3 - DEIM UT0 - Curso 25·26 - 14 de enero de 2026 - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
Grabación de la tutoría 3 de DEIM, en la que se habló sobre la resolución de la tarea de la UT0.
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.
00:00:02
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
00:00:19
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í
00:00:28
Es decir, se pueden dejar planteados y, bueno, pues sin borrarlos, decidiendo cuál se aplica y cuál no, ¿vale?
00:00:37
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.
00:00:45
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.
00:01:02
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í.
00:01:24
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.
00:01:46
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.
00:02:04
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.
00:02:21
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.
00:02:43
Pero es muy interesante, que creo que nunca lo he dicho y no es como algo que se enfatiza mucho,
00:02:50
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.
00:02:55
Porque cuando estamos aquí con los scripts, todo se suele enrevesar un poco.
00:03:05
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.
00:03:10
La energía, los impactos, bueno, en principio aquí tampoco importa que tengan decimales
00:03:30
Pero bueno, se pueden poner como Floats
00:03:38
Luego una booleana que nos sirva para ir activándose cuando el juego está detectando que la partida se ha superado o no
00:03:39
O mejor dicho, cuando la nave ha perdido todas las vidas y por tanto se ha acabado el juego
00:03:49
Bueno, pues que se llama aquí Alive, de está vivo
00:03:55
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.
00:03:57
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?
00:04:15
Entonces bueno, este repaso rápido es sobre todo para ver un poco la lógica de cómo resolver esto
00:04:29
Es importante que cuando estamos generando estas variables
00:04:35
Si no las hacemos públicas o se muestran en un serialize field
00:04:41
Bueno, pues que las inicialicemos en el start
00:04:45
Es decir, que cuando arranque el juego sea cuando coja los valores
00:04:49
recordad, ya esto ya lo hemos visto
00:04:52
que también se puede inicializar
00:04:55
en el propio momento de la declaración
00:04:57
de la variable, como variable global
00:04:59
por ejemplo, el problema que hay
00:05:01
si hacemos estas variables públicas
00:05:03
o sería de isFile es que luego
00:05:05
en el editor podremos cambiar el valor
00:05:07
y sobre escribirá lo que
00:05:09
tenemos aquí marcado, por tanto
00:05:11
¿qué es lo mejor? en el momento de
00:05:13
comenzar el juego, o de que arranque este script
00:05:15
mejor dicho, pues decimos
00:05:17
oye, estas variables tienen que valer tanto
00:05:19
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.
00:05:21
Por convención, estamos un poco viendo que la energía, la vida que tiene la nave es de 100 puntos.
00:05:32
La nave, evidentemente, dentro de esta booleana como la estamos planteando, pues empieza viva.
00:05:38
La nave está participando en el juego y hemos puesto, marcado que hay tres vidas.
00:05:44
Aquí se marcan, digamos, los ingredientes principales de este juego que ahora vamos a poner en marcha.
00:05:50
Luego, al comenzar el juego, esta línea se podría borrar, ¿vale?
00:06:00
Pues todo lo que es la... voy a desampliar un poco para que se vea todo de un solo vistazo.
00:06:04
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.
00:06:15
este método, bueno aquí se ha puesto que
00:06:38
según se arranca el juego
00:06:40
se ejecute, pero
00:06:42
lo importante, dado que
00:06:44
si no se ejecutaría todos los fotogramas
00:06:47
es que claro, que se vaya
00:06:49
ejecutando en distintos momentos
00:06:50
si no ponemos una condición
00:06:52
y pusiéramos que este impacto se ejecutara
00:06:54
en el update sin más
00:06:57
en cada fotograma se estaría ejecutando
00:06:58
por tanto hay que pensar, y esto también
00:07:00
pasará con las corrutinas y en el IE
00:07:02
en el numerator, que hay que conseguir que estos
00:07:04
bucles, update no deja de ser un bucle que se está ejecutando cada fotograma, que dentro
00:07:06
de estos bucles haya algo que detenga una condición que haga que se cumpla o no, en
00:07:11
este caso el método de esta operación de impacto. Veremos que en este caso, ahora que
00:07:20
ya hemos visto ciertas interacciones, se puede hacer marcando que no pase nada, que no se
00:07:25
ejecute el impacto hasta que no, en este caso, demos a la barra espaciadora, aparte se pone
00:07:31
otra condición, recordad a este operador de
00:07:36
conjunción de condiciones
00:07:38
¿no? Bueno, pues la nave tiene que estar
00:07:40
viva. ¿Esto por qué?
00:07:42
Por ejemplo, diréis
00:07:45
porque al final del juego cuando se agoten
00:07:46
todas las vidas, ¿vale? La nave
00:07:48
pasará a estar muerta
00:07:50
pero el juego sigue reproduciéndose. ¿Qué ocurre?
00:07:51
Que no querremos que se
00:07:55
produzcan más impactos
00:07:56
porque la nave ya está muerta
00:07:58
aunque diéramos a la barra espaciadora no queremos
00:08:00
que siga restando vida ni que haga nada en ese
00:08:02
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.
00:08:04
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.
00:08:33
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,
00:08:45
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.
00:08:57
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.
00:09:21
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.
00:09:47
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.
00:10:03
Por ejemplo, aquí, si el impacto es mayor que la energía, es decir, el escudo que tiene la nave,
00:10:17
impepinablemente vamos a perder una vida. Se ha perdido toda la energía, todo el escudo, y perderemos una vida.
00:10:23
Cuando se cumpla esta condición, restaremos una vida.
00:10:28
Recordad este operador de menos menos, que va decreciendo lo que valga, por eso también es interesante,
00:10:32
aunque podría ser un float, que sean números enteros, y si teníamos tres vidas,
00:10:38
inmediatamente, si se diera la condición de que el impacto es mayor que la energía, se restaría una vida.
00:10:43
De primera es esta condición, la primera vez que se ejecute el impacto, en este caso sería en el start,
00:10:49
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.
00:10:56
Por tanto, nunca va a morir en esa primera iteración.
00:11:01
Entonces, lo que hará será, aunque luego tengamos otras condiciones dentro, saltará de esta llave a esta e irá al else.
00:11:04
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.
00:11:11
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.
00:11:27
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.
00:11:40
¿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.
00:11:52
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.
00:12:10
¿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.
00:12:26
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.
00:12:50
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.
00:13:11
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.
00:13:35
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.
00:13:50
Con el bucle for lo bueno es que tenemos tres apartados que nos permiten definir cuándo se tiene que desarrollar ese bucle, ¿vale?
00:14:07
El primero es declarar la condición o una variable que es el que va a servir para los otros dos aspectos.
00:14:16
Entonces, declarando una variable, bueno, pues en este caso de tipo int puede ser de tipo float también, ¿vale?
00:14:25
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?
00:14:30
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.
00:14:52
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.
00:15:06
¿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.
00:15:31
¿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.
00:15:45
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.
00:15:56
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.
00:16:14
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.
00:16:42
Y aparte, bueno, pondrá un mensaje una última vez de has muerto, que es lo que se ha guardado en este message.
00:16:54
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,
00:17:02
Pero esto evidentemente se podrá trasladar a la vida o comportamientos de un videojuego real.
00:17:23
Entonces yo ahora mismo estoy aquí.
00:17:35
Se ha lanzado ese primer impacto que se daba por defecto en el Start, sin ningún tipo de condición.
00:17:37
Y ya nos ha restado como 52 aproximadamente.
00:17:45
Si yo ahora voy pulsando la barra espaciadora.
00:17:48
A ver que me haga caso.
00:17:50
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.
00:17:53
pues por ejemplo aquí después de esto poner
00:18:08
debug log
00:18:10
escudo restablecido a 100
00:18:11
que nunca tengáis miedo a poner
00:18:13
comprobaciones o mensajes
00:18:16
en mitad del código
00:18:18
es verdad que tener muchas
00:18:20
a veces pueden suponer que salgan
00:18:22
muchas de golpe y no enterarte pero siempre
00:18:24
se pueden ir comentando
00:18:27
rápidamente o comentando para ver
00:18:28
las instrucciones
00:18:31
bueno si continúo y le doy otra vez
00:18:33
vale pues ahora me ha quitado del orden de
00:18:34
63 de vida, le vuelvo a dar
00:18:36
y me ha matado, ya solo queda una vida
00:18:39
y me queda esa vida
00:18:41
le vuelvo a dar, me ha quitado
00:18:42
73, le vuelvo a dar
00:18:44
ahora me ha quitado muy poquito, como 17
00:18:47
y le vuelvo a dar y he muerto
00:18:49
ahora, como el alive ha pasado a ser
00:18:50
falso y ya no se cumple la condición de
00:18:53
de pulsar la barra espaciadora
00:18:55
que teníamos aquí, vale, esta segunda condición
00:18:57
del if, no se cumple, por mucho
00:18:59
que de yo a la barra espaciadora
00:19:01
el juego ya se sigue
00:19:03
reproduciendo podrían pasar más cosas o si hay otros scripts o si el juego tuviera otras otros
00:19:05
comportamientos configurados otros otras acciones pero en este juego tal y como está hemos acabado
00:19:11
ya sólo quedaría cerrar la partida y y hecho vale esta sería un poco la forma más rápida y
00:19:17
digamos directa de conseguir esto que ocurre que por supuesto voy con otro script que en este caso
00:19:26
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.
00:19:34
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.
00:19:54
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.
00:20:17
¿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.
00:20:38
¿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.
00:20:58
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.
00:21:13
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.
00:21:33
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.
00:21:49
damos los valores en el start
00:22:05
como he comentado antes
00:22:08
aunque aquí esté ya
00:22:09
inicializado
00:22:12
nada impide a que
00:22:13
en el start, para asegurarnos que cuando se lance
00:22:16
el script tenga los valores que queremos
00:22:18
se vuelvan a poner, es un poco redundante
00:22:20
es verdad que se podría eliminar
00:22:22
esto y el resultado sería exactamente el mismo
00:22:24
lo vamos a hacer por un poco de limpieza
00:22:26
pero
00:22:28
ahí está
00:22:29
y cuando se arranca el juego
00:22:31
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.
00:22:34
¿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.
00:23:04
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.
00:23:21
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.
00:23:37
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.
00:23:51
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,
00:24:01
en los enumerators normalmente lo que nos va a interesar siempre es establecer un bucle, ya sea mediante un for o un for infinito,
00:24:09
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.
00:24:19
O se puede usar un while, con una condición que siempre se esté ejecutando.
00:24:32
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.
00:24:37
¿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.
00:25:01
¿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.
00:25:17
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.
00:25:34
Una vez tenemos eso, pues igual que hemos hecho antes, se puede hacer una aleatoriedad del daño que va a hacer esta nave
00:26:00
Y es un poco lo que se ha visto anteriormente
00:26:07
Si el impacto del asteroide es mayor del escudo, se restará una vida
00:26:11
Pondrá el aviso pertinente de has perdido una vida
00:26:15
Y si al perder la vida hemos perdido, básicamente
00:26:17
Aparte de poner un aviso de final de juego, pues la nave pasa a ser falsa
00:26:24
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.
00:26:28
¿Qué ocurre? Que aunque no se ejecute el bucle, este enumerator está en marcha.
00:26:37
Por tanto, también suele estar bien acompañarlo de un stop corrutín.
00:26:44
El juego puede seguir continuando con otras acciones.
00:26:48
y con esto lo que hacemos es cerrar esta línea de ejecución para que no siga corriendo y bueno
00:26:53
pues optimizamos un poco que no que no siga algo ahí dando vueltas aunque ya no tenga nada en su
00:26:59
interior pero bueno vale entonces cuando se acaba el juego cuando las vidas son igual a cero pues
00:27:05
todo esto pasa a ser para indicar una partida acabada aunque se siga reproduciendo el juego
00:27:11
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?
00:27:20
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.
00:27:37
Mientras sea mayor que 0, pues hará el número de vueltas convenientes para mostrar el número de vidas que tiene, ¿vale?
00:27:49
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.
00:27:59
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,
00:28:07
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.
00:28:24
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?
00:28:42
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...
00:28:56
A ver, estaba en editar, dentro de avanzadas, editar avanzadas, hay uno para dar formato al documento.
00:29:14
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.
00:29:29
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.
00:29:42
Vale, pues lo dicho, si el impacto de la nave es diferente a ser mayor al escudo de la nave
00:30:06
Es decir, que con este L se está indicando que todo lo que sea que el escudo de la nave
00:30:16
Que el impacto es menor que el escudo de la nave, por tanto no se resta vida
00:30:22
Pues va a dar como resultado lo que hay aquí dentro
00:30:26
Que el escudo de la nave se va a haber resentido, restando el valor del impacto
00:30:28
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?
00:30:34
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.
00:31:00
Irá aquí abajo, volverá arriba y dice, a ver, ¿el bucle se ejecuta? Sí, pues otra vez, otra vez, otra vez. Cada dos segundos.
00:31:13
Aquí se puede poner el valor que se quiera, una variable que guarde un número.
00:31:19
Pero fijaos que también se podría hacer algo interesante que es aleatorizar incluso el tiempo que permanece interrumpido.
00:31:23
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.
00:31:37
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.
00:31:51
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.
00:32:06
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.
00:32:30
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.
00:32:57
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.
00:33:20
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.
00:33:35
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.
00:34:01
cuando demos a la barra espaciadora
00:34:28
se lanzará el método recibir impacto
00:34:32
y aquí en vez de hacer
00:34:34
que la variación del impacto
00:34:36
cambie ya dentro del método
00:34:39
o del enumerator
00:34:41
que es lo que pasaba en estos momentos
00:34:43
lo que vamos a hacer es
00:34:45
que vamos a pasar
00:34:47
esto simplemente para ver otra forma de hacerlo
00:34:48
como parámetro del método
00:34:51
este random range
00:34:53
entonces cuando estemos
00:34:54
declarando este recibir impacto, este método, vamos a pasar una variable
00:34:57
de tipo float que se llama fuerza de impacto que luego podremos ir usando
00:35:02
en su interior. Lo que valga la fuerza de impacto dependerá de lo que
00:35:06
indiquemos aquí al invocarla. Aquí no tiene mucho sentido en el sentido
00:35:10
de que solo se llama a esta variable, a este método, cuando damos a la
00:35:16
barra espaciadora, pero podría ser otro juego que si en vez de dar a la
00:35:22
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.
00:35:25
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
00:35:37
que estamos ejecutando cambiaría según cómo se ha invocado ese método, ¿vale?
00:35:49
Luego tenemos otro en el update preparando con la tecla R que solo atenderá cuando ya hayamos perdido la partida
00:35:54
y el vivo pasa a ser falso, que es el de reiniciar el juego.
00:36:01
Aquí estamos metiendo un aspecto más allá que es que cuando ha muerto la nave tenemos la posibilidad de reiniciar
00:36:05
para que todo vuelva a ser como era al comienzo, ¿vale? Lo vemos ahora después.
00:36:11
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í.
00:36:15
Entonces, de momento empezamos el juego y no queremos reiniciarlo, sino dar a la barra espaciadora y lanzamos.
00:36:28
En esencia, lo que se encuentra aquí es exactamente igual, formulado con otro tipo de variables, quizá con otro orden.
00:36:36
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.
00:36:43
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.
00:36:58
¿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?
00:37:19
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.
00:37:40
¿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.
00:37:55
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.
00:38:07
¿Vale? Cada dos segundos
00:38:30
Saldrá este mensaje, una vez se ha perdido la partida
00:38:32
Que se pulsa la R
00:38:34
Pensad que aquí
00:38:36
Tenemos planteado que
00:38:38
Cuando pulsamos la R, y si estamos ya muertos
00:38:39
Vivo es falso, se reinicia
00:38:42
El juego, ¿vale?
00:38:44
Reiniciar el juego, y esto es más avanzado
00:38:46
Y es algo de lo que se hablará
00:38:48
En la unidad 4, se puede
00:38:49
Conseguir
00:38:52
Reiniciando el nivel, ¿vale?
00:38:53
Para eso, hay una biblioteca
00:38:55
Que ya veréis, esto es más avanzado y voy a pasar ahora mismo
00:38:57
de puntillas, una biblioteca que se puede añadir, que es este Unity Engine
00:38:59
Scene Management, que es que
00:39:03
podemos luego usar esta clase de Scene Manager y cargar
00:39:07
una escena, en este caso la misma en la que estábamos, y resetea
00:39:11
todo para que vuelva a empezar de nuevo. Al pulsar la R
00:39:15
y con esta instrucción se reinicia el juego. Pero
00:39:19
también lo que se podría hacer al reiniciar el juego es aquí poner
00:39:23
nuevamente en vez de reiniciar todo
00:39:27
entonces reiniciaría también el script
00:39:31
reiniciaría el nivel por completo
00:39:33
es volver a estos valores del comienzo
00:39:35
que teníamos en el start
00:39:39
copiarlos y volvería a empezar la partida
00:39:40
como si nada
00:39:44
porque el vivo volvería a ser true
00:39:44
podríamos pulsar el espacio
00:39:48
y volveríamos a estar exactamente como al comienzo
00:39:50
y otra vez tendríamos las tres vidas
00:39:55
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?
00:39:57
Además, como este bucle en este momento vivo pasaría a ser true, este enumerator, al ser falso, dejaría de reproducirse.
00:40:14
¿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.
00:40:27
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.
00:40:51
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.
00:41:13
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.
00:41:23
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.
00:41:32
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.
00:41:46
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.
00:41:58
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.
00:42:10
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?
00:42:28
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.
00:42:56
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.
00:43:14
- Materias:
- Imagen y Sonido
- Niveles educativos:
- ▼ Mostrar / ocultar niveles
- Formación Profesional
- Ciclo formativo de grado superior
- Primer Curso
- Segundo Curso
- Subido por:
- Daniel M.
- Licencia:
- Todos los derechos reservados
- Visualizaciones:
- 3
- Fecha:
- 14 de enero de 2026 - 20:18
- Visibilidad:
- Clave
- Centro:
- IES CIFP a Distancia Ignacio Ellacuría
- Duración:
- 43′ 36″
- Relación de aspecto:
- 1.78:1
- Resolución:
- 1920x1080 píxeles
- Tamaño:
- 507.29 MBytes