Tutoría 3 - DEIM - UT2 y 0 - Curso 23·24 - 14 Diciembre

Y el propósito de hoy va a ser intentar resolver la tarea cero que dejamos pendiente, que me 00:00:00

sirve también para que sigamos introduciendo ciertos conceptos y si surgen dudas pues me 00:00:07

vais comentando, ¿de acuerdo? 00:00:12

El enunciado de esta tarea, a diferencia de otros, es más o menos corto, por eso lo voy 00:00:15

a leer un poco más en detalle para ir desglosándolo, ¿vale? 00:00:19

Que es un poco, creo también, el planteamiento que deberíamos hacer de cara a nuevas tareas, 00:00:21

o estemos viendo los enunciados, etcétera, que tiene muchos ítems, mucho contenido, 00:00:27

pero bueno, se trata de ir poco a poco, ¿vale? 00:00:32

Entonces, básicamente lo que se quiere conseguir es, de una forma no muy visual, imagina un 00:00:36

juego de acción en el que el jugador maneja una nave espacial a través de un campo de 00:00:41

asteroides. 00:00:45

Esto visualmente no se va a ver, sirve para dar un contexto, pero no se va a ver. 00:00:46

Entonces, vamos a tener una nave que va a ir por un campo de asteroides y va a ir recibiendo 00:00:49

impactos, ¿no? 00:00:53

Si recibe uno de estos impactos, su escudo se reducirá en una magnitud igual a la fuerza 00:00:54

del impacto. 00:00:58

Vale, aquí cuando vamos analizando, yo siempre recomiendo hacer una primera leída, ¿no? 00:00:59

Y luego ya ir al detalle, pero primero una leída general para tener todo el concepto, 00:01:04

aunque ni siquiera similemos bien lo que se nos pide, viene bien, porque luego puede haber 00:01:10

más cosas que tener en cuenta que si no leemos y vamos primero parte a parte, pues nos vamos 00:01:15

perdiendo, ¿vale? 00:01:21

Bueno, ya está enunciado, entiendo que lo leeríais ya, entonces voy a ir un poco rápido, 00:01:22

pero vamos. 00:01:26

Lo que quiero que vayamos señalando es qué tipo de variables o qué, digamos, elementos 00:01:27

vamos a tener en este código, ¿no? 00:01:31

Para empezar, cuando tenemos esta nave, va a existir lo que se llama el impacto, va a 00:01:33

haber un escudo que se irá reduciendo en magnitud igual a la fuerza del impacto, ¿vale? 00:01:38

En otros días ya estuve diciendo, al final todo lo que vaya ocurriendo al programar o 00:01:43

gran parte de ello se va a basar en cálculos matemáticos, ¿no? 00:01:48

Que por eso habíamos empezado a ver operadores, sumas, cómo ir asignando variables, algunos 00:01:52

tipos de variables, entonces ya podemos incluso en una hoja o lo que voy a hacer ahora mismo, 00:01:57

que va a ser crear, por ejemplo, una nueva escena, ¿no? 00:02:03

Cuando vamos trabajando en distintos proyectos o en distintos niveles de un mismo proyecto, 00:02:07

¿vale? 00:02:12

Están, ya lo habréis visto, lo que se llama la escena, ¿no? 00:02:13

Es donde vais creando la jerarquía de GameObjects, ¿vale? 00:02:15

Y aquí aparece el nombre de esa escena, Tutoría UT1, ¿vale? 00:02:18

Pero podéis ir creando más, es decir, yo aquí tengo esta UT1, pero luego tengo una 00:02:22

que hice de pruebas código y tengo, cuando la cargo, pues aquí se carga y tenemos aquí 00:02:26

los distintos GameObjects, ¿vale? 00:02:31

Para ir trabajando, digamos, como va a ser algo independiente a lo que estaba haciendo 00:02:35

el otro día, ¿vale? 00:02:39

Pues voy a hacer un nuevo, ¿vale? 00:02:40

Con un clic derecho creamos un nuevo y buscamos, de todas las opciones que tenemos aquí, una 00:02:42

nueva escena, ¿vale? 00:02:48

La nueva escena se guardará en la misma carpeta en la que hemos estado generando las escenas, 00:02:49

donde la hemos creado, ¿vale? 00:02:58

Si recordad que si luego vais al proyecto, a la estructura de carpetas de Windows o de 00:02:59

Mac, pues esto aparece replicado en el proyecto, ¿vale? 00:03:03

Pues esto va a ser Tarea UT0, lo voy a llamar así para que sea identificativo. 00:03:06

Pues me meto ahí y tengo la escena, digamos, virgen para ir trabajando, ¿no? 00:03:12

Y como todo esto va a ser visual, digo, más que visual, va a ser programación pura y 00:03:17

dura, ¿vale? 00:03:22

No vamos a ver, en este caso, no se pide la parte visual de este juego de asteroides. 00:03:23

Voy a generar un nuevo script, ¿vale? 00:03:28

Que va a ser donde voy a ir desarrollando todo el código, ¿no? 00:03:30

Pues por ejemplo lo voy a llamar Tarea UT0, ¿vale? 00:03:34

Y lo que va a ser es el script en el que yo voy a ir trabajando ese código que va 00:03:40

a ir generando la mecánica que se pide, ¿no? 00:03:43

Y entonces, ya hemos estado viendo anteriores días y ya lo habéis hecho, por ejemplo, 00:03:48

la primera tarea, ¿vale? 00:03:52

Que lo primero que tenemos que ir declarando son esas variables, esas cajas con las que 00:03:54

vamos a ir operando, ¿no? 00:03:59

Y en este caso ya, pues por ejemplo, nos han comentado que va a haber un escudo, ¿vale? 00:04:00

Que va a tener una energía, ¿no? 00:04:07

Pues que va a tener la nave, ¿vale? 00:04:11

Que ya diremos que empiece con un nivel, ¿no? 00:04:13

Un número, una vida, pues por ejemplo el 100% o 100 puntos, ¿no? 00:04:17

Algo así, ¿vale? 00:04:21

Ya sabemos que hay un escudo. 00:04:23

Da error porque de momento no sabemos de qué tipo es la caja, ¿vale? 00:04:24

Sí que sabemos cuando vamos viendo el enunciado, sí que vamos viendo al ir leyendo que va 00:04:27

a haber como sumas y restas de números, ¿no? 00:04:34

Porque al final la fuerza, esa cantidad de fuerza que va a tener el impacto, pues al 00:04:36

final la forma de representarla que tenemos es a partir de un número, ¿no? 00:04:41

Entonces también, luego lo podemos borrar fácilmente, pero igual que tenemos un escudo 00:04:46

va a haber una variable o va a haber una cifra, ¿vale? 00:04:51

Que vamos a ir jugando, que es el impacto del meteorito. 00:04:54

Le voy a poner impacto, ¿vale? 00:04:57

Porque como no hay más impactos que la nave no va a disparar ni nada, lo pongo impacto. 00:04:58

Nuevamente, estamos abriendo una caja que todavía no le estamos diciendo de qué tipo. 00:05:03

Hasta que no lo hagamos esto dará error. 00:05:07

Simplemente estoy como enunciando elementos, ¿vale? 00:05:08

Para ir teniéndolos aquí como variables globales que ya vimos el otro día, que son 00:05:11

las que están al comienzo de la clase y que no se nos vaya pasando e ir estructurando 00:05:15

un poco qué vamos a buscar, ¿no? 00:05:21

Luego dice, si esa magnitud es superior a la fuerza del escudo que le queda, se le restará 00:05:23

una vida. 00:05:27

Por tanto, hay vidas en este juego, ¿vale? 00:05:28

Yo sé que va a haber en algún momento que vamos a tener que decirle si tiene una, tres, 00:05:32

siete vidas, ¿vale? 00:05:37

Pues ya voy generando ahí. 00:05:38

Es buena práctica que como ya sabemos que son números, es decir, no va a haber que 00:05:39

introducir un texto ni se va a operar con un texto, sabemos que estas variables van 00:05:44

a ser de tipo numérico, pues ir guardándolas como variable de tipo numérico, ¿no? 00:05:48

Ya vimos que podía ser un número entero o podía ser un número, un float, ¿no? 00:05:54

Es un número que permite también decimales. 00:05:59

¿Qué problema tiene? 00:06:02

Pues, por ejemplo, el número de vidas, luego, por supuesto, podemos volver y cambiar, pero 00:06:03

el número de vidas normalmente va a ser uno, tres, pero no va a ser tres con dos vidas, 00:06:07

¿no? 00:06:12

Entonces, eso ya nos deja deducir que el tipo de variable que nos interesa aquí sería 00:06:13

un int, ¿no? 00:06:17

A menos que luego veamos que necesitamos, que ahí vendríamos y lo cambiaríamos sin 00:06:18

problema. 00:06:21

El impacto y el escudo, si seguimos leyendo, no define nada de cómo debe hacer, ¿vale? 00:06:22

Así que se define si es la última vida que le queda de las iniciales, que pueden 00:06:28

ser tres, por ejemplo, ¿vale? 00:06:31

De primeras, vamos a decir que van a ser tres vidas, ¿vale? 00:06:33

Recordad que cuando declaramos esta variable, también podemos decir ya la caja con cuántos 00:06:37

elementos, en este caso, cuántas vidas tendría, ¿vale? 00:06:43

De momento lo defino así, ¿vale? 00:06:47

Este juego va a tener la nave tres vidas, ¿vale? 00:06:49

Si en algún momento recordad que estas variables no sabemos a qué se refieren, no son descriptivas, 00:06:52

siempre podemos decir lives o vidas, nave, ¿vale? 00:06:58

Importante, algunos os corregí que las variables, no los métodos que si veis empiezan con mayúscula, 00:07:05

las variables siempre deberían empezar, tal y como estamos estableciendo la convención, 00:07:10

con minúscula. 00:07:14

Y para separar palabras usamos esta mayúscula, ¿vale? 00:07:15

En cualquier caso, siempre saldrá un aviso en pantalla indicando lo que ha ocurrido, 00:07:22

si se ha reducido un escudo, si se le ha quitado una vida o si ha muerto. 00:07:26

Esto lo puedes hacer mandando un mensaje a consola, mediante el método print o el método 00:07:29

debug log. 00:07:33

Son análogos. 00:07:35

Hasta ahora, el resto de días, hemos estado viendo debug logs, ¿vale? 00:07:36

Entonces, vamos a usar en cierto momento el debug log para ir informando de lo que ocurre, 00:07:40

tened en cuenta que a diferencia de las tareas que estamos haciendo, como no va a haber un 00:07:45

resultado visual, lo que vamos a ir viendo es, en consola, si se va sumando, si va muriendo 00:07:49

o no. 00:07:55

Es decir, van a ir siendo operaciones que se ven representadas en línea de texto. 00:07:56

Y para ir apelando a esta escritura en la consola, vamos a usar el método debug log, 00:07:59

¿vale? 00:08:04

Un poco como hacíamos el otro día, que si en el start poníamos debug log hola, por 00:08:05

decir, ahí se ha puesto un mensaje solo, pues ponemos un hola, se mostraría eso, ¿no? 00:08:11

No lo voy a demostrar porque esto ya lo hemos visto, si tenéis dudas, me vais diciendo. 00:08:19

Pero sí que va a haber un debug log aquí como esperando a que sigamos trabajando. 00:08:23

Nuevamente, hasta que no le digamos qué tiene que mostrar en consola, dará error. 00:08:27

Pero bueno, para irnos acordando, ¿vale? 00:08:31

Esto es verdad que tampoco aporta mucho, pero puede estar bien a veces ir apuntando ciertas 00:08:34

cosas o, si no queremos que dé error, pues lo comentamos y ya sabemos que va a haber 00:08:39

que usar debug logs continuamente. 00:08:43

Además de esto, cuando nos quitan una vida y no hayamos muerto, realizaremos un bucle 00:08:45

a través de las vidas que nos quedan. 00:08:51

Esta parte del bucle, vamos a hacer un bucle para que nos vaya informando de cuántas vidas 00:08:53

nos quedan. 00:08:57

Esta la vamos a hacer un poco más adelante, ¿vale? 00:08:58

No vamos a ir centrando en esta parte primera. 00:08:59

Aquí tenemos este diagrama que va demostrando un poco qué va ocurriendo en cada momento, 00:09:05

pero de momento vamos a empezar con lo básico, que es que tenemos un escudo, una fuerza de 00:09:12

impacto que va a ocurrir y unas vidas que tendrá en esa nave. 00:09:19

Luego, como nos dice también, y esta lógica también me va interesando, es que hay que 00:09:23

ir informando de que una vez el jugador ha perdido todas las vidas, tiene que haber algo 00:09:31

que en algún momento nos indique si está vivo o está muerto. 00:09:38

Es verdad que estas vidas, cuando lleguen a cero, previsiblemente, significará que 00:09:42

está muerto, ¿vale? 00:09:46

Pero el otro día vimos que había un tipo de variable, que son las booleanas, que solo 00:09:48

podían ser verdadero o falso, y puede ser una variable que nos sirva para decir, oye, 00:09:52

este personaje está vivo hasta que deje de estar vivo, que entonces se interpretará 00:09:59

que está muerto. 00:10:04

¿Eso qué significa? 00:10:05

Que este personaje, ahora mismo, dado que no estamos haciendo nada más, va a empezar 00:10:07

con una variable que tiene guardado que es vivo. 00:10:12

Esto lo vamos a usar ahora a continuación cuando hagamos condicionales. 00:10:14

Es decir, vamos a decir, cuando pulses esta tecla, si estás vivo también, sucederá 00:10:18

algo. 00:10:25

¿Por qué? 00:10:26

Porque si está muerto, lo que vamos a querer es que en consola ponga, está muerto, ¿vale? 00:10:27

Ese tipo de controles, en vez de estar, digamos, haciendo equiparaciones con números o haciendo 00:10:30

operaciones con números, se pueden poner estos, el otro día lo describí, como semaforitos, 00:10:36

que sirven para decir, ¿esto está activo o no está activo? 00:10:41

Entonces es una forma cómoda emplear los booleanos para indicar que algo, pues digamos, 00:10:44

da permiso a otras operaciones o no. 00:10:52

Es decir, mientras esté vivo el juego se está desarrollando, pero si en algún momento 00:10:54

conseguimos que esto valga falso, significará que el juego está parado y ya no tiene sentido 00:10:58

mover la nave ni que se puedan generar más impactos porque deberíamos pasar a otra cosa 00:11:03

que ya sería un menú de Game Over o reiniciar el juego, ¿vale? 00:11:08

Sería otra operación hasta que no tuviéramos otra vez al personaje vivo, ¿no? 00:11:12

Que reiniciemos el juego, etcétera, ¿vale? 00:11:16

Entonces de momento pues vamos también a poner una variable que va a servir para poder 00:11:20

nosotros ir marcando si está vivo o no el personaje. 00:11:28

Hay una cosa que el otro día vimos también, que es que yo estoy aquí declarando lo que vale 00:11:31

cada una de estas variables, pero lo más correcto o lo recomendable en muchos casos es, 00:11:37

aunque esté declarado aquí, yo quiero que siempre que se inicie el juego o se inicie el script, 00:11:43

como ya comenté, que coja unos valores por defecto, ¿vale? 00:11:48

¿Por qué? Porque si, por ejemplo, hacemos una variable pública o un serializeField, 00:11:52

como íbamos haciendo en la nave para ver en el inspector de Unity, serializeField, 00:11:57

para ver en el inspector de Unity las operaciones que podamos ir haciendo, ¿vale? 00:12:03

Es decir, si yo ahora mismo, recordad, importante, lo vuelvo a decir, 00:12:08

quien haya hecho la tarea 1 seguramente ya se ha pegado con esto, 00:12:12

pero todo lo que vayamos a hacer en este script hasta que no creamos un elemento, 00:12:15

un GameObject, el tipo que sea, en este caso voy a generar un Empty, 00:12:19

que va a ser, pues yo qué sé, contenedor... voy a poner juego directamente, ¿vale? 00:12:23

Hasta que no asignemos este script a un GameObject, esto no va a funcionar, 00:12:29

es decir, nada está cogiendo este script para operar con él, ¿vale? 00:12:34

Una vez lo introducimos, ved que la VidasNave, esto ya sonará de la otra tarea también, 00:12:38

pues está aquí esperando a que podamos modificar los valores. 00:12:43

Y tenemos aquí que tiene 3 por defecto, porque le hemos dicho que sea 3. 00:12:46

El problema que tiene de trabajar así, ¿vale? que puede haber, 00:12:50

es que si nosotros aquí ponemos 7, ¿vale? y guardamos, realmente aquí sigue poniendo 3, 00:12:54

es decir, en el código no lo hemos tocado. 00:13:01

En este momento lo que prevalecería es lo que hemos cambiado en el inspector. 00:13:03

Nosotros cuando testeemos el juego vamos a estar trabajando en el inspector. 00:13:08

Entonces digamos que esto que hay aquí sobrescribe al inspector, ¿vale? 00:13:11

¿Qué puede pasar? que estamos aquí funcionando y trabajando, 00:13:15

haciendo pruebas como ya haremos y estamos aquí tocando y lo dejamos así. 00:13:19

Entonces empezamos el juego y estamos viendo el código y decimos, 00:13:22

joe, yo he puesto 3 y este juego pone que tiene 117 vidas. 00:13:26

A medida que se van teniendo más GameObjects, vamos a ir teniendo más variables aquí. 00:13:30

Entonces digamos que no tener un control claro de qué hemos dejado en el inspector, ¿vale? 00:13:35

Y también recordad, que os lo dije el otro día, lo último que comenté, 00:13:42

que podemos ir cambiando estos valores para ir probando, ¿vale? 00:13:45

Ya lo veremos con las posiciones, pero podemos decir, a ver cómo funciona esto con 226. 00:13:49

Por ejemplo, cuando le damos una velocidad a un objeto. 00:13:53

Podemos estar aquí probando y dices, ah, 258, perfecto. 00:13:55

Y para la reproducción y sigues trabajando. 00:13:58

Daos cuenta que todos los cambios que se hagan mientras estamos en play no se quedan guardados. 00:14:01

Ha pasado del 258 al 110 que estaba indicado antes de darle al play. 00:14:06

Entonces digamos que el inspector, pues por ejemplo, para arrastrar GameObjects, 00:14:12

como hicimos el otro día en los campos para definir qué es la instancia, etc. 00:14:17

Está muy bien porque esos campos no se varían tanto, no se mueven tanto. 00:14:21

Y una de las asignas se queda más estable. 00:14:25

Pero cuando metemos valores, que a veces se hace a través del inspector, puede dar problemas. 00:14:27

Para, digamos, minimizar esto, tener mayor control, lo que es buena práctica, 00:14:33

ahora no me interesa que sea SerializeFill. 00:14:38

Bueno, lo dejo en SerializeFill para que veamos lo que estoy indicando. 00:14:40

Pero tener en cuenta que aunque yo haya aquí inicializado una variable, 00:14:43

si yo luego, al arrancar el juego, le digo que VidasNave valga 8, 00:14:48

luego lo vuelvo a cambiar a 3, que es lo que me interesa, 00:14:55

si yo guardo, pues efectivamente, previamente va a estar aquí encontrándose con un 3 00:14:57

y en el editor con el 168 de antes. 00:15:04

Pero en cuanto arranquemos el juego y este script se arranque, 00:15:07

vais a ver que en el Start se ha puesto el 8. 00:15:11

Entonces nos aseguramos que siempre que arranquemos el juego 00:15:13

sea el valor que estamos indicando. 00:15:16

Esto es importante porque a veces nos podemos volver un poco locuelos. 00:15:19

Veis que incluso cuando dejo de ejecutar, pues ya vuelve a ponerse otro valor. 00:15:23

Pero sí que nos aseguramos de este modo que al arrancar el juego 00:15:27

se pone con la cifra que queremos. 00:15:30

Entonces, como nosotros tenemos bien claro, por lo que estamos definiendo en el enunciado, 00:15:32

que esta nave va a arrancar cada vez que iniciemos el juego, 00:15:36

no solo cuando se arranque el juego la primera vez, no. 00:15:40

Cada vez que se inicie este script, pues va a valer 3, ¿vale? 00:15:43

Lo cual, pues mira, me permite incluso dejar esto sin serialize. 00:15:46

Sigue siendo privado y no se puede operar en el inspector. 00:15:50

Así no podemos tampoco modificarlo ni meterle mano. 00:15:53

Y ya, siempre que arranquemos el juego, la nave va a tener 3 vidas. 00:15:56

Aparte, lo mismo sucede con lo de vivo. 00:16:03

Para que veáis cómo se traduce un serialize fill en una variable de tipo booleano, 00:16:07

claro, aquí no va a salir un número. 00:16:12

Este tipo de variables lo que hace es contener un verdadero, 00:16:16

como ahora cuando está marcado, o un falso. 00:16:20

Y sucede lo mismo. 00:16:22

Aparecía marcado porque habíamos dicho que esto era true. 00:16:24

A ver, voy a ver, no vaya a ser que me estéis escribiendo en el chat. 00:16:27

Vale, perdón. 00:16:29

Le hemos puesto true. Si aquí dijéramos que es false, 00:16:30

cuando guardemos y vayamos, está sin tachar. 00:16:34

Y ojo, lo he cambiado en el código y he guardado, 00:16:38

pero cuando cambio algo en el código y ya lo hemos inicializado 00:16:41

en, digamos, como variable global, 00:16:44

nuevamente esto no se sobreescribe. 00:16:49

Es decir, aunque yo ahora ponga aquí true... 00:16:51

A ver, espera. 00:16:54

Quito el true, lo dejo en false. 00:16:56

Y yo ahora digo, quiero que esto sea true, que todavía no he guardado. 00:16:59

Antes estaba como false y guardo. 00:17:02

Cuando vuelvo aquí, al inspector, veis que sigue siendo false. 00:17:04

Porque esto no está diciendo en ningún momento, 00:17:08

oye, pero cámbiamelo del inspector, que sí que es lo que hace el start. 00:17:10

Oye, cuando arranca el juego me lo configura con este valor. 00:17:14

Por eso vamos a seguir la misma lógica. 00:17:17

También para decir que si estamos vivos o no, 00:17:20

ese semáforo que nos permite luego booleano, 00:17:22

que nos permite ir marcando condiciones, 00:17:25

pues yo digo, no, cuando arranca el juego, por defecto, 00:17:27

pues está vivo esta nave, ¿vale? 00:17:29

Pues nada, ya lo tenemos así puesto. 00:17:33

Y luego vamos a decir también que la energía del escudo, 00:17:36

pues igual, vamos a basarnos en que el escudo, por defecto, 00:17:40

arranca con 100 de vida. 00:17:44

Cuando llegue a cero, 00:17:45

pues será que ha perdido el escudo y pierde una vida, ¿vale? 00:17:47

Hasta aquí, ¿qué tal? ¿Me vais siguiendo? 00:17:50

Claro, bueno, Daniel me está preguntando 00:17:52

si se toman primero los valores del inspector antes que el código. 00:17:55

Es decir, si lo tienes como variables globales, 00:17:59

que las variables globales se declaran, 00:18:03

pero no hay ningún momento, 00:18:06

no sucede como en Start o en Update, 00:18:08

que estás diciendo momentos de ejecución, 00:18:10

aquí se están solo declarando a nivel de código. 00:18:11

Pero cuando estás jugando no hay momentos como aquí. 00:18:14

Estos métodos sirven para que el inspector 00:18:16

Pero cuando estás jugando no hay momentos como aquí. 00:18:19

Estos métodos sirven para definir cuando sucede algo. 00:18:21

Como aquí en ningún momento, cuando arrancamos el juego, 00:18:24

ni en ningún momento estamos diciendo 00:18:27

que vuelva a mirar el código para dar estos valores, 00:18:28

al final el que gana ahí, el que se queda, 00:18:32

es lo que estemos marcando en el inspector, 00:18:35

¿vale? Cuando estén serializadas o públicas. 00:18:37

Si queremos que siempre se arranque o cada fotograma, 00:18:40

que también podría ser otra cosa, ahora lo usaremos, 00:18:44

queremos que cada fotograma se vaya variando un valor, 00:18:46

pues ahí ya lo pondríamos en este sitio. 00:18:50

Pero sí, el orden sería el valor con el que declaremos, 00:18:53

aquí declaramos para luego ir usando en el resto de métodos. 00:18:57

Cuando arranca el juego, si lo hemos puesto en Start, 00:19:01

cogerá estos valores y por en medio digamos que está 00:19:05

el valor que pongamos en el inspector, 00:19:09

que siempre que no lo volvamos a sobreescribir 00:19:14

en un momento de ejecución, gana o se sobreescribe a esto 00:19:16

que tenemos aquí como variables globales. 00:19:20

Sí, querías hablar, ¿verdad? 00:19:22

Sí, para dejarlo así, las generales, 00:19:25

los valores que hacemos globales, 00:19:32

no es como obligatorio darle un valor, 00:19:34

lo que tenemos que buscar ahí es el tipo de caja, 00:19:36

por decirlo así. 00:19:39

Efectivamente. 00:19:40

Si va a ser una booleana, un número entero, 00:19:41

un tipo float, ¿no? 00:19:44

Eso es. 00:19:46

Es como lo importante en la global. 00:19:47

Y ya luego en cada método sí que le damos valor 00:19:49

según lo que queramos. 00:19:53

Eso es. 00:19:55

A ver, a veces nos puede interesar ya declararlo aquí 00:19:56

como por defecto y si es privada, 00:19:59

no lo vamos a cambiar nunca con el inspector. 00:20:01

Vale. 00:20:03

Pues se puede inicializar como había hecho aquí, ¿vale? 00:20:04

Pero sí, es justo lo que has descrito. 00:20:07

Aquí digamos que vamos preparando todas las cajas 00:20:09

para ir usándolo en todos los métodos, 00:20:11

porque recordad que dije el otro día 00:20:13

que lo que esté en una llave superior, 00:20:15

los métodos se pueden usar en clases 00:20:17

y en funcionalidades, digamos, encapsuladas dentro. 00:20:21

Pero si yo declaro aquí un int declarado, 00:20:24

y digo esto vale 100, 00:20:30

si yo luego quiero operar, y está dentro del start, 00:20:33

si yo luego quiero trabajar con declarado y decir 00:20:36

declarado cada fotograma a suponer 500, 00:20:38

da fallo porque no lo hemos declarado en un nivel superior. 00:20:42

Solo podremos operar con declarado dentro de esta área. 00:20:45

Sí, esto es importante, 00:20:51

porque si no a veces empezamos a declarar variables 00:20:52

y cuidado, el tipo de variable, 00:20:55

daos cuenta de que solo se pone una vez. 00:20:57

Se crea la caja y luego ya cuando queramos trabajar con ella 00:20:59

apelamos al nombre, 00:21:03

pero veis que aquí ya no vuelve a poner int. 00:21:04

¿Más o menos? 00:21:07

Perfecto. 00:21:09

Si vais haciendo las prácticas lo iréis asimilando, 00:21:11

pero muy buena pregunta y bien visto todo. 00:21:15

Es decir, aquí como globales, 00:21:18

para luego no preocuparnos a lo largo del juego, 00:21:20

pues vamos generando aquí las cajas 00:21:22

y luego ya las vamos jugando aquí. 00:21:23

En ciertos momentos nos puede interesar, 00:21:25

no, yo no quiero que del start salga esto, 00:21:27

entonces declararemos aquí la variable. 00:21:29

Y sí que es verdad que en este juego 00:21:32

está bien que creamos aquí las cajas 00:21:34

y según arranque le damos ya los valores 00:21:37

con los que empieza el juego. 00:21:39

Y así no hay nada que nos quite el sueño 00:21:41

de que he tocado en el inspector 00:21:44

o no sé en qué momento algo va a sobreescribirlo. 00:21:46

Que lo mismo sucede, 00:21:49

simplemente para que veáis, 00:21:51

yo aquí puedo decir vidas nave 3 00:21:52

y luego aquí en el update decir 00:21:55

en vez de vidas nave empieza el juego. 00:21:57

Y digo este personaje está vivo 00:22:02

y luego le pongo aquí no, 00:22:04

pero luego está muerto en el update. 00:22:06

Tened en cuenta, 00:22:08

empieza el juego y está vivo, 00:22:12

pero en el siguiente fotograma pasa a estar muerto. 00:22:13

Entonces vais a ver que si yo aquí hago 00:22:17

una llamada a consola para que me diga 00:22:20

qué vale la variable vivo, 00:22:23

pues lo que me va a decir según arranca el juego 00:22:27

va a ser verdadero, 00:22:29

pero luego va a pasar a ser falso. 00:22:30

Que esto se va modificando. 00:22:32

Hay que ir viendo la lógica de ejecución del juego. 00:22:34

Entonces hago la prueba para que lo veáis. 00:22:37

A veces me hago un lío con tanta ventanita. 00:22:44

Y yo le doy aquí al play y veis que el primero, 00:22:47

bueno y lo detengo. 00:22:50

Cuando detenemos se queda aquí 00:22:51

hasta que volvamos a ejecutar, 00:22:53

se queda guardado en todos los mensajes. 00:22:54

Como se han creado muchos voy al principio del todo. 00:22:56

Y no se ha generado porque el primer fotograma 00:23:00

me lo ha sobrescrito. 00:23:03

Como se ha hecho más de 900, 00:23:04

se ha sobrescrito. 00:23:06

Pero mira, si yo le doy play y lo paro antes, 00:23:07

el primero debería ser verdadero. 00:23:10

A ver. 00:23:13

Empieza como vivo, verdadero. 00:23:16

Vale, hay un problema. 00:23:19

Y este son las sutilezas que suceden aquí. 00:23:21

Como hemos puesto el debug log 00:23:25

después de que lo hemos convertido en falso, 00:23:27

hasta que no pasa ese primer fotograma 00:23:29

y esto pasa a ser falso, 00:23:31

no se escribe en consola. 00:23:33

Por tanto, siempre aparece como falso. 00:23:35

Que no es lo mismo que si yo digo, 00:23:37

ojo, en cuanto pase este fotograma, 00:23:39

empieza verdadero, 00:23:41

va al siguiente fotograma y dice, 00:23:43

vale, escribo vivo y ya pasa falso. 00:23:44

Ya siempre que vaya haciéndose el bucle por fotogramas, 00:23:47

será falso. 00:23:50

Porque yo le he dicho que la variable es falso. 00:23:51

Y le he dicho que es falso 00:23:53

y se guarda, si os fijáis, 00:23:55

en la caja vivo, que es donde la hemos declarado. 00:23:57

Entonces siempre va a valer falso 00:24:00

cada vez que vuelva a bajar, 00:24:03

porque se meterá en el update 00:24:04

y aquí está leyendo este falso que se ha guardado aquí. 00:24:05

Ahora sí que, 00:24:09

espero no equivocarme, 00:24:10

si le doy al play, borro 00:24:11

todo lo que hay en consola con este clear. 00:24:13

Si le doy a play, 00:24:16

y paro. 00:24:17

Ahora cuando suba, sí que veo que el primero es verdadero 00:24:18

y ya a partir de ahí todo es falso, falso, falso. 00:24:21

Todos los fotogramas. 00:24:23

Fijaos que el orden altera el resultado bastante. 00:24:24

¿Vale? 00:24:28

¿Entendéis un poco qué ha sucedido ahora 00:24:29

en lo que acabamos de ver? 00:24:31

Que son sutilezas, pero son importantes. 00:24:32

Bueno, espero que sí. 00:24:42

Sí, entendido, vale. 00:24:45

Vale, pues, 00:24:47

a ver, que este no es el script que tenemos entre manos. 00:24:49

Vale. 00:24:52

Pues ahora mismo lo que tenemos aquí es 00:24:53

una nave 00:24:55

con tres vidas, 00:24:57

un escudo de 100 00:24:58

y luego va a haber un impacto, ¿vale? 00:24:59

Fijaos que esta variable no la he declarado, 00:25:01

pero no la he inicializado. 00:25:04

Oye, aquí de momento 00:25:06

yo puedo hacer 85 cajas y no hay por qué usarlas, ¿vale? 00:25:08

Se pondrá de un color diferente, ¿vale? 00:25:11

A lo mejor a veces no pondrá 00:25:13

como que está en uso, ¿vale? 00:25:16

Pero no pasa nada por declarar variables 00:25:18

que no se usan. 00:25:21

De hecho, si... 00:25:22

Bueno, lo que pasa es que tengo más scripts 00:25:23

y va a ser más lío. 00:25:25

Pero puede poner que en alguno, 00:25:26

como advertencia, 00:25:28

no como error rojo, 00:25:29

pone en tal código, 00:25:30

el campo... 00:25:31

Bueno, este es de otro código, 00:25:32

pero dice lo mismo. 00:25:33

Está asignado, 00:25:34

pero su valor nunca es usado. 00:25:35

¿Vale? 00:25:36

Esto significa que se ha declarado una variable, 00:25:37

pero nunca se ha usado. 00:25:39

¡Ojo! 00:25:40

¿Para qué la declaraste si no la vas a usar? 00:25:41

Hombre, lo suyo aquí no es poner cosas demás, 00:25:43

pero oye, que si más adelante la vamos a usar, 00:25:45

aquí podemos generar más cajas 00:25:47

y tampoco pasa nada, la verdad. 00:25:48

¿Vale? 00:25:50

Que cuando salga este error que tenéis... 00:25:51

No es error, es advertencia, 00:25:53

que os salga aquí 00:25:54

y ponga este mensajico, 00:25:55

significa eso. 00:25:57

¿Vale? 00:25:58

Vale. 00:25:59

Vamos a continuar. 00:26:00

Eh... 00:26:02

Lo que vamos a querer, básicamente, 00:26:03

es que cuando... 00:26:05

Y esto lo quito porque no me interesa, ¿vale? 00:26:07

Lo he escrito a modo ejemplo. 00:26:09

Está vivo cuando empieza, 00:26:10

una escuda de 100 00:26:11

y una vida en nave. 00:26:12

Lo que vamos a hacer, ¿vale? 00:26:14

Es que cada vez 00:26:15

que le demos a una tecla, 00:26:17

por hacerlo de una forma, ¿vale? 00:26:19

Cada vez que demos, por ejemplo, 00:26:20

a la barra espaciadora, 00:26:21

que eso es algo que ya, más o menos, 00:26:22

se indica en el tema 2 cómo se hace 00:26:24

y lo vemos ahora, ¿no? 00:26:26

Vamos a decir que cada vez 00:26:27

que demos a... 00:26:29

a la barra espaciadora, 00:26:31

se genera un impacto. 00:26:33

Es decir, como que la nave se ha chocado 00:26:34

con el... 00:26:36

con... 00:26:37

con un meteorito, ¿vale? 00:26:39

Y le genera un daño, ¿no? 00:26:41

Claro, porque hasta que no pase eso, 00:26:43

pues el impacto no se está generando. 00:26:45

Entonces... 00:26:47

podríamos... 00:26:49

En el enunciado se indica 00:26:50

que sea cada dos segundos. 00:26:51

Para eso habría que hacer 00:26:52

una corrutina, probablemente, 00:26:53

o algún tipo de... 00:26:55

de... 00:26:58

de invoke, ¿vale? 00:27:00

Que sirve para lanzar métodos 00:27:02

en diferido, ¿vale? 00:27:04

Esto está como ya introducido 00:27:05

también en estos temas, 00:27:06

pero prefiero hacerlo de otra forma 00:27:07

ahora mismo. 00:27:09

Lo que vamos a hacer es eso, 00:27:10

que cuando le damos a la barra espaciadora, 00:27:12

se genere un impacto, ¿no? 00:27:13

Ahora es cuando empezamos 00:27:16

a entrar en el terreno 00:27:17

de los condicionales, ¿vale? 00:27:18

Que es, básicamente, 00:27:20

que declaramos una condición 00:27:22

que, si se cumple, se ejecuta algo. 00:27:24

¿Vale? Este tipo de condicionales, 00:27:26

de estructuras de control condicional, 00:27:28

¿vale? Tienen una... 00:27:30

digamos, estructura 00:27:32

la más básica posible, 00:27:33

que es la del if, ¿no? 00:27:34

Es decir, bueno, 00:27:36

en la traducción en inglés de if 00:27:37

sería así. 00:27:38

Si pasa algo, pues sucede tal cosa, ¿no? 00:27:39

Si ponemos aquí un if, 00:27:41

entre unos paréntesis, 00:27:43

podemos poner 00:27:44

qué condición se debe de dar 00:27:45

para que se ejecute 00:27:47

lo que hay entre llaves. 00:27:48

¿Vale? Es decir, 00:27:50

igual que tenemos aquí las llaves 00:27:51

que abren y cierran 00:27:52

y encapsulan, ¿no? 00:27:53

Aquí vamos a tener paréntesis 00:27:55

que, si... 00:27:58

imagino que os recuerdan un poco, 00:28:00

por ejemplo, a los del instant seed. 00:28:02

Aquí no son parámetros 00:28:03

como en un método, 00:28:05

con el que vamos diciendo 00:28:06

cómo se ejecuta un método, 00:28:08

pero sí que nos permite 00:28:10

meter condiciones 00:28:11

para que se dé una condición o no. 00:28:13

¿Vale? 00:28:16

Si cuando pasa el update 00:28:17

en cada fotograma 00:28:19

se cumple lo que hay dentro de este if, 00:28:20

entre estos paréntesis, 00:28:22

se ejecuta esto. 00:28:23

Si no se ejecuta, 00:28:24

seguirá y lo ignorará. 00:28:25

Nos sirve para decir, por ejemplo, 00:28:27

que algo suceda. 00:28:28

Entonces, 00:28:30

lo que vamos a hacer, por ejemplo, 00:28:31

es si... 00:28:33

Y vamos a pensarlo 00:28:34

a nivel, no programación, 00:28:35

sino a nivel 00:28:37

escritura humana normal, ¿no? 00:28:39

Si... 00:28:42

Lo voy a poner entre comentarios. 00:28:44

Si... 00:28:46

Si pulso la tecla 00:28:48

espacio, 00:28:50

la barra espaciadora, 00:28:52

digamos, se provoca un impacto. 00:28:54

¿Vale? 00:28:56

Hasta entonces, 00:28:58

el juego se irá desarrollando 00:28:59

y el escudo seguirá en 100 00:29:01

y las vidas en 3. 00:29:02

¿Vale? 00:29:03

Esto, si pulso la tecla espacio, 00:29:04

es decir, 00:29:05

si pulso la tecla espacio, 00:29:06

vamos a ver... 00:29:08

Ya habéis visto el tema 2, 00:29:10

que para poder apelar 00:29:11

a teclas del teclado, 00:29:13

hay que usar la clase Input, 00:29:17

que es la que define 00:29:19

las entradas de... 00:29:21

Puede ser tanto de... 00:29:24

Es decir, las interacciones 00:29:26

que haga el jugador. 00:29:27

Puede ser tanto con el teclado, 00:29:28

con el joystick, 00:29:29

con un ratón, 00:29:30

con un gamepad. 00:29:31

Se define en distintas formas. 00:29:33

Pero también hay que ir definiendo, 00:29:35

después de esta clase, 00:29:37

cómo recibe esa interacción. 00:29:39

Ahora mismo, 00:29:41

y en el tema 2 aparece descrito, 00:29:42

por favor, cuando podáis, 00:29:44

si no lo habéis hecho ya, 00:29:46

irle echando un ojo. 00:29:48

Voy a poner aquí el apartado 00:29:49

en el que sale, 00:29:51

simplemente para que sepáis 00:29:52

de dónde sale esto. 00:29:53

Pero en el tema 2... 00:29:54

A ver... 00:29:57

En el tema... 00:29:58

Espera, voy a colapsar. 00:29:59

Y en el tema 2, 00:30:01

en los contenidos, 00:30:04

hay una sección 00:30:05

que es la de interactividad. 00:30:07

Y en la clase Input, 00:30:09

que es esa clase de la que acabo de hablar, 00:30:11

luego hay muchos métodos 00:30:13

que ya vienen preconfigurados. 00:30:15

El GetMouseButtonDown. 00:30:16

Si estamos usando, por ejemplo, 00:30:18

un botón de un gamepad. 00:30:20

O GetKeyDown, 00:30:22

para detectar una tecla. 00:30:23

Una tecla del teclado, 00:30:26

que es el que nos interesa ahora mismo. 00:30:27

Luego está el... 00:30:30

Los GetMouseButtons. 00:30:32

Esto hay que irlo viendo. 00:30:35

Los GetAxis. 00:30:36

Esto lo veremos para la tarea 2. 00:30:37

Hoy no me voy a meter en esa tanto, 00:30:38

pero que sepáis que también está aquí. 00:30:40

Entonces, 00:30:42

hay distintos métodos que podemos usar. 00:30:43

Si queremos usar 00:30:45

lo relacionado con el teclado del ordenador, 00:30:46

pues nos está indicando 00:30:50

que tenemos que usar uno que se llama GetKey. 00:30:52

Y cuando vais escribiendo, 00:30:56

dice yo voy a coger una tecla del teclado. 00:30:58

De hecho, si vemos aquí la descripción, 00:31:01

devuelve verdadero, 00:31:04

mientras el usuario mantiene la tecla 00:31:06

identificada por el KeyCode. 00:31:08

Ahora vemos lo que es el KeyCode. 00:31:10

Cuando hacemos un input de tipo GetKey, 00:31:12

veis que yo mientras estoy escribiendo, 00:31:14

voy a ponerlo, 00:31:16

salen tres opciones. 00:31:17

Y esto va a pasar con muchas más cosas. 00:31:19

Por eso es importante 00:31:21

que nos detengamos aquí un poquillo. 00:31:22

Está el GetKeyDown, 00:31:24

el GetKeyUp y el GetKey. 00:31:26

Esto lo explica Álvaro en su vídeo. 00:31:28

Aquí yo pongo dos. 00:31:32

Por ahí se explica también 00:31:34

que si no pone nada hace otra operación. 00:31:35

Pero es porque es interesante 00:31:37

o es importante que el software sepa 00:31:39

que si recibimos la señal 00:31:44

de cuando pulsamos la barra espaciadora 00:31:48

según la pulsamos, 00:31:50

es decir, al pulsarla, 00:31:51

si mientras la tenemos mantenida 00:31:52

o cuando soltamos. 00:31:54

Si yo, por ejemplo, pongo GetKeyDown, 00:31:56

lo que estamos diciendo es 00:32:00

que la tecla que ahora pongamos 00:32:02

detecte que se está ejecutando algo 00:32:04

cuando la pulsemos. 00:32:07

Si aquí pusiéramos GetKeyUp, 00:32:09

significa que podemos pulsar 00:32:11

la barra espaciadora, 00:32:13

pero no pasa nada hasta que la soltemos. 00:32:15

Y en ese momento se ejecutaría 00:32:17

lo que hay aquí. 00:32:18

Si por el contrario lo dejamos como GetKey, 00:32:20

se refiere a que mientras tengamos pulsado, 00:32:23

como está en el Update, 00:32:26

cada fotograma va a ir interpretando 00:32:27

que sucede algo. 00:32:29

Por ejemplo, si estamos moviendo un personaje 00:32:30

y usamos la tecla de avanzar, 00:32:32

la W o la flecha hacia arriba, 00:32:34

pues tendríamos que usar este método 00:32:36

porque queremos que se vaya ejecutando 00:32:39

continuamente mientras mantengamos pulsada. 00:32:41

Entonces, aquí es donde tenemos que decir 00:32:43

de qué forma recibimos ese input. 00:32:46

Aquí estamos diciendo, en este caso, 00:32:48

que sea mientras mantenemos una tecla pulsada. 00:32:50

Pero es verdad que queremos que el impacto 00:32:55

solo se realice una vez cada vez que pulsemos. 00:32:57

Por tanto, este no es el mejor método. 00:32:59

Lo mejor es que según pulsamos la tecla, 00:33:01

pues se ejecuta una vez. 00:33:03

Es decir, aunque mantengamos pulsado, 00:33:05

solo se baja la tecla una vez. 00:33:07

Y luego, posteriormente, 00:33:09

ahora dejo paso a la palabra que me han dicho por ahí. 00:33:11

Posteriormente hay que decirle, en este caso, 00:33:14

qué tecla es la que se mete. 00:33:17

Esto se puede meter de varias formas, 00:33:19

pero la más común, 00:33:21

cuando estamos hablando de inputs de teclado, 00:33:23

es usar un comando que es el KeyCode, 00:33:26

que luego, posteriormente, 00:33:28

tiene las propiedades que se refieren 00:33:30

a las distintas teclas que hay. 00:33:32

¿Veis qué es la IntelliSense? 00:33:34

Si quiero poner al tocar la L, 00:33:36

o al tocar la X, 00:33:38

o al tocar la tecla Borrar, 00:33:40

aquí están todas las teclas 00:33:42

habitualmente que hay en un teclado. 00:33:44

En nuestro caso, Tabulador, no. 00:33:46

Queremos que sea la barra espaciadora. 00:33:48

Space Key. 00:33:52

Esa es la que vamos a poner al completar. 00:33:54

De momento, lo que vamos a hacer 00:33:56

es usar el teclado 00:33:58

para ir interactuando con el juego. 00:34:00

Esta estructura hay que aprendérsela. 00:34:04

Cada vez que queramos decir 00:34:07

que se va a interactuar 00:34:09

con el teclado, 00:34:11

en este caso, 00:34:13

va a haber que apelar a la clase Input, 00:34:15

decirle de qué modo recibe esa tecla, 00:34:17

si al pulsarla, al soltarla o mientras la mantenemos, 00:34:19

y luego hay que decir qué tecla. 00:34:21

Con esta sintaxis. 00:34:23

Esto hay que aprendérselo así. 00:34:25

Lo tenéis en el tema que os estaba enseñando. 00:34:27

Por ejemplo, aquí. 00:34:29

Aquí pone los dos ejemplos 00:34:31

que cuando pulsamos y soltamos, 00:34:33

cuando pulsamos, 00:34:35

lanzará el mensaje 00:34:37

de barra espaciadora, está pulsado. 00:34:39

Cuando soltamos, ya ha sido 00:34:41

released, soltada. 00:34:43

Luego, no es lo mismo 00:34:45

que, por ejemplo, decir 00:34:47

en GetKey, que mientras estemos dando 00:34:49

a la flecha de arriba de la cruceta 00:34:51

que tenemos en el teclado, 00:34:53

va a ir poniendo fotograma 00:34:55

mientras estemos pulsando. 00:34:57

La tecla arriba está mantenida. 00:34:59

Y cuando pulsamos la tecla de abajo, 00:35:01

mientras la tengamos, cada fotograma 00:35:03

se irá ejecutando, lo que pone aquí, 00:35:05

que va a imprimir en consola, 00:35:07

esa tecla está pulsada. 00:35:09

¿Alguien quería preguntar algo? 00:35:11

Por favor, 00:35:13

si es con... 00:35:15

¿Me oyes? 00:35:17

Te oigo, pero bajísimo. 00:35:19

Ahora mejor? 00:35:21

Nada, muy poco. 00:35:23

Te lo pongo por escrito, ¿vale? 00:35:25

Vale. 00:35:27

Es mejor, básicamente, 00:35:29

porque así queda la grabación, 00:35:31

porque por escrito no suele enseñar, pero bueno. 00:35:33

Sí, escríbemelo. 00:35:35

Entonces, mientras lo va escribiendo, 00:35:39

voy preparando lo siguiente. 00:35:41

Pues es, mientras pulsamos 00:35:43

la tecla espacio, 00:35:45

por ejemplo, podemos decir... 00:35:47

Que lo demuestre, ¿no? 00:35:51

Para saber yo que estamos 00:35:53

pulsando, pues que diga 00:35:55

has pulsado. 00:35:57

¿Vale? 00:35:59

A la barra espaciadora. 00:36:01

Vale. 00:36:05

Sí. 00:36:07

Sí, ahora voy a hacer la demostración. 00:36:09

Está Francisco Javier preguntando. 00:36:11

Entiendo que si dejas pulsado continuamente 00:36:13

se ejecuta de manera infinita hasta que sueltas 00:36:15

en el caso del GetKey. 00:36:17

Efectivamente, ¿vale? 00:36:19

Guardo, y ahora mismo tenemos un GetKeyDown. 00:36:21

¿Vale? Si yo ahora voy al 00:36:23

al juego, 00:36:25

¿vale? 00:36:27

Y le doy. Fijaos que no pasa nada 00:36:29

hasta que yo, no sé si lo vais a oír, 00:36:31

pero lo voy comentando, pulso la tecla 00:36:33

y se lanza el mensaje, ¿vale? 00:36:35

Y aunque yo pulse y deje pulsado, 00:36:37

tengo pulsado ahora mismo 00:36:39

la barra espaciadora, no se están sumando más mensajes. 00:36:41

Solo se lanza una vez. ¿Vale? 00:36:43

Es decir, he dado tres veces y cada vez 00:36:45

que he pulsado, pues me ha lanzado el mensaje. 00:36:47

¿Vale? ¿Qué pasaría 00:36:49

si yo esto lo pongo 00:36:51

en vez de GetKeyDown, lo pongo como GetKey? 00:36:53

¿Vale? Esto recordad que es 00:36:55

porque está dentro del Update y cada fotograma 00:36:57

está buscando qué pasa aquí dentro. Si lo pusiéramos 00:36:59

en el Start, 00:37:01

solo se ejecutaría una vez si 00:37:03

estamos pulsando la tecla a la vez que 00:37:05

se inicia este script. 00:37:07

Solo se ejecuta una vez. 00:37:09

Entonces, esto hay que tener cuidado siempre 00:37:11

de ver dónde estamos asignando cada cosa. 00:37:13

Si ahora decimos GetKey, 00:37:15

pues vamos aquí, 00:37:17

lanzo el juego 00:37:19

y yo voy a pulsar y voy a mantener presionado. 00:37:21

Entonces vais a ver que van a empezar a sumarse 00:37:23

los mensajes porque mientras 00:37:25

mantengo pulsado y le doy ahora mismo y mantengo pulsado, 00:37:27

¿vale? Pues todos esos fotogramas 00:37:29

se están ejecutando. 00:37:31

Cuando yo suelto, suelto, 00:37:33

ahí ha parado. Vuelvo a pulsar, 00:37:35

veréis que ahora empieza a moverse esto, 00:37:37

porque ya más de mil mensajes no los contabiliza, 00:37:39

pero veis que va cambiando el código de tiempo. 00:37:41

Mientras mantengo pulsado, se ejecuta suelto. 00:37:43

Y ahora ya no avanza 00:37:45

el tiempo, ¿vale? 00:37:47

Eso es básicamente lo que permite que 00:37:49

el juego vaya sabiendo si 00:37:51

estamos pulsando una tecla y si tiene que avanzar 00:37:53

el personaje medio segundo, 00:37:55

tres segundos, pues según lo que estemos pulsando. 00:37:57

¿Vale? 00:38:01

Pues sigo, 00:38:05

que entiendo que 00:38:07

entonces 00:38:09

tenemos aquí 00:38:11

para continuar. 00:38:13

Aquí lo que vamos a decir, a ver, que no sé 00:38:15

si me ha escrito... 00:38:17

Vale, entiendo que 00:38:19

todo ha controlado. Vale. 00:38:21

Y no me decís, ¿eh? 00:38:23

Cuando damos a la barra espaciadora, lo que vamos a decir 00:38:25

es que haya... A ver, que creo que 00:38:27

alguien me ha puesto... Sí. 00:38:29

Alguien ha pedido palabra. 00:38:31

... 00:38:35

Bueno, entiendo que 00:38:39

ha sido un error. 00:38:41

No, bajísimo. 00:38:43

A ver, voy a ponerme yo... 00:38:47

Es que, de verdad 00:38:51

que es que no te oigo. Oigo que hablas, pero 00:38:53

no entiendo lo que dices. A ver, voy a probar yo 00:38:55

si es que yo tengo el... 00:38:57

Voy a poner música en YouTube 00:38:59

un segundo para ver si me 00:39:01

está llegando el sonido. 00:39:03

A ver... 00:39:07

Nada, sí que lo... 00:39:13

Sí que escucho. 00:39:15

Algo pasa con el nivel de tu micrófono. 00:39:17

Siempre en el update. Sí. 00:39:23

Siempre que queramos captar una interacción 00:39:25

tiene que estar, recordad, todo el rato 00:39:27

revisando que se está 00:39:29

realizando la interacción. Si lo ponemos en el start 00:39:31

esto funciona una vez y ya se olvida 00:39:33

lo que hay aquí. Solo se asigna según se 00:39:35

arranca. Todo lo que sea interacciones 00:39:37

tenemos que ir usando el update. 00:39:39

Luego aparecerán más tipos de 00:39:41

momentos, de métodos que marcan momentos 00:39:43

pero sí, efectivamente 00:39:45

en el update. Porque si no 00:39:47

no se está metiendo aquí continuamente para comprobar 00:39:49

que esto sea cierto. 00:39:51

Importante, me sirve 00:39:53

que la condición o condiciones 00:39:55

que pueda haber más de una, que tengamos aquí 00:39:57

lo que hace 00:39:59

básicamente es devolver si algo es 00:40:01

verdadero o falso. Es decir, 00:40:03

si se cumple la condición, 00:40:05

se cumple, pues esto significa 00:40:07

verdadero. Internamente está 00:40:09

interpretando 00:40:11

esto que es un verdadero. 00:40:13

En ciertas ocasiones 00:40:15

hay que pensarlo así. Si 00:40:17

es verdadero lo que hay dentro, como que estoy pulsando 00:40:19

la tecla espaciadora, pues se genera esto. 00:40:21

Aquí lo que vamos a decir, por ejemplo, 00:40:23

es que cada vez que pulse la tecla 00:40:25

impacto 00:40:27

el impacto 00:40:29

valga 50 00:40:31

y ese impacto 00:40:33

va a ser lo que va a hacer 00:40:35

es afectar al escudo que tenemos 00:40:37

y vamos a tener un escudo 00:40:39

que va a ser lo que vale 00:40:41

ya escudo menos 00:40:43

impacto. Esto lo vimos 00:40:45

el otro día y podía sonar un poco 00:40:47

extraño. 00:40:49

¿Entendemos lo que quiere 00:40:51

decir esto? Que se repite 00:40:53

la variable. 00:40:55

Básicamente aquí 00:40:57

ya os dije que no es como un algoritmo 00:40:59

de toda la vida. Lo importante es 00:41:01

entender que aquí estamos abriendo 00:41:03

una variable, 00:41:05

estamos apelando a una variable, 00:41:07

ponemos un igual que significa 00:41:09

esta variable va a pasar a valer lo que pongamos 00:41:11

aquí. 00:41:13

Para decir que hay que restar 00:41:15

la escudo, lo que es el impacto, 00:41:17

aquí hay que volver a poner 00:41:19

impacto. No vale componer simplemente 00:41:21

que a lo mejor es lógico decir 00:41:23

en este momento escudo menos impacto. 00:41:25

Hay que guardarlo en su variable. 00:41:27

Escudo va a pasar a valer 00:41:29

lo que yo le diga 00:41:31

aquí a continuación. 00:41:33

Escudo que empieza siendo 100 00:41:35

va a ser 100 menos 50 y va a valer 50. 00:41:37

De hecho voy a poner un impacto 00:41:39

un poco menos redondo, 40. 00:41:41

Entonces empieza el juego 00:41:43

100 y dice 00:41:45

el escudo va a valer ahora 00:41:47

100 menos 40. 00:41:49

Cuando vuelva a dar otra vez 00:41:51

y voy a poner porque solo quiero que ocurra una vez 00:41:53

con gateKeyDown, cuando yo le dé 00:41:55

se ejecutará otra vez el escudo 00:41:57

y será el escudo que había guardado 00:41:59

anteriormente menos 40. 00:42:01

Y así consecutivamente. 00:42:03

¿Eso qué significa? Que si yo 00:42:05

lanzo el juego ahora, a ver si he guardado... 00:42:07

Sí, sí he guardado. 00:42:09

Lanzo el juego, 00:42:11

cuando arranca el juego 00:42:13

yo le doy play 00:42:15

a la barra espaciadora. 00:42:17

¿Algo está pasando? 00:42:19

No se está viendo nada. 00:42:33

Importante. Otra de las cosas que ponía 00:42:35

en el enunciado es que tenemos que ir mostrando 00:42:37

en consola, porque si no de ninguna forma 00:42:39

vamos a ver qué ocurre. ¿Qué va sucediendo? 00:42:41

Internamente 00:42:43

escudo va valiendo menos. 00:42:45

Pero para ir viendo qué sucede, 00:42:47

en este caso ahora mismo tenemos la forma de 00:42:49

mostrarlo en consola. 00:42:51

Cuando arranca el juego voy a poner 00:42:53

el escudo 00:42:55

de la nave 00:42:57

tiene una energía 00:42:59

de... 00:43:01

Y aquí os dije el otro día 00:43:03

la concatenación. 00:43:05

Cuando vamos poniendo mases 00:43:07

al lado de un string, lo que vamos haciendo 00:43:09

es convertir en texto 00:43:11

a los números, aunque sean de tipo numérico, 00:43:13

sirve para convertirlo 00:43:15

en número. Tiene una energía de 00:43:17

en este caso 100 00:43:19

y luego le voy a decir... 00:43:21

Esto es importante que entendáis lo que estoy haciendo 00:43:23

que ya lo hemos hablado más veces, 00:43:25

por eso voy un poco más rápido. 00:43:27

Y tiene... 00:43:29

¿Cuántas vidas? 00:43:31

Se ve aquí 00:43:33

el número de vidas más 00:43:35

vidas. 00:43:39

Cuando arranca el juego 00:43:41

va a poner la frase 00:43:43

el escudo de la nave tiene una energía de... 00:43:45

pondrá el número que tenga 00:43:47

la variable 00:43:49

y tiene, esto es literal, 00:43:51

en este caso va a poner 3 vidas. 00:43:53

Cuando arranque el juego 00:43:55

va a poner 00:43:57

he guardado... 00:43:59

Arranco el juego 00:44:01

y según arranca el juego pone el escudo de la nave 00:44:03

tiene una energía de 100 y tiene 3 vidas. 00:44:05

Esto, como os estáis dando cuenta, 00:44:07

no es algo literal que yo he puesto, está cogiendo el valor 00:44:09

con el que se ha inicializado. 00:44:11

Son variables 00:44:13

que podemos también convertir 00:44:15

en textos de esta forma. 00:44:17

Si cogemos un texto 00:44:19

y se lo sumamos, lo concatenamos 00:44:21

no es una suma, es igual que aquí, no es un igual 00:44:23

es una asignación. Hacemos esta 00:44:25

concatenación pues nos permite ir viendo estos mensajes. 00:44:27

¿Qué ocurre? Que aquí lo que vamos a 00:44:29

creer es que aparte cuando 00:44:31

pulsemos, no todos los fotogramas, solo 00:44:33

cuando pulsemos la tecla espacio 00:44:35

sucede esto y nos devuelve el mensaje 00:44:37

de cuánto queda. 00:44:39

Nuevamente, el orden de donde 00:44:41

vamos poniendo las cosas es muy importante. 00:44:43

Ahora lo vemos más concreto. 00:44:45

La nave 00:44:47

tiene 00:44:49

tiene tanto escudo 00:44:55

Es decir, la nave tiene 00:45:01

un espacio literal y pondrá 00:45:03

el escudo que tenga en ese momento 00:45:05

que se ha guardado aquí, después de hacerse esta operación 00:45:07

de escudo. 00:45:09

¿Esto qué significa? Que yo ahora cuando vaya 00:45:11

al juego le doy 00:45:13

según arranca me pone la vida y cuando yo 00:45:15

dé a la barra espaciadora 00:45:17

la nave tiene 60 00:45:19

de escudo. Veis que aquí se ha juntado 00:45:21

porque como no he dejado un espacio literal 00:45:23

aquí, no lo respeta. 00:45:25

Esto es fácil de solucionar. Y si vuelvo a dar 00:45:27

a la tecla espacio, cuando le vuelva a dar 00:45:29

volverá a hacer esta operación. 00:45:31

Todo lo que hay dentro del if. 00:45:33

Si el escudo ha pasado a valer 60, ahora 00:45:35

uy va, que estoy aquí. Como no he guardado 00:45:37

no pasa nada, sigue la ejecución. Le doy a la 00:45:39

barra espaciadora 00:45:41

a ver que como he cambiado el código creo que 00:45:43

se ha ido el traste. 00:45:45

Ahí está. 00:45:47

Ahora, vuelvo a darle, arranca 00:45:49

el juego, pone 100, le doy una vez, 60 00:45:51

le vuelvo a dar, 20, le vuelvo a dar, 00:45:53

menos 20 y así voy restando. 00:45:55

Cada vez que le voy dando 00:45:57

se va generando la condición. 00:45:59

Importante, no es lo mismo poner 00:46:01

este mensaje aquí que ponerlo fuera del if. 00:46:03

Porque si es fuera del if 00:46:05

se irá cada fotograma 00:46:07

mostrando este mensaje. 00:46:09

Entonces, se va a convertir 00:46:11

esto en una amalgama de cosas, 00:46:13

de mensajes que no va a dejar nada claro. 00:46:15

Va a poner el primero, ha salido 00:46:17

a milésima de segundo el primer mensaje 00:46:19

y ahora cuando le dé a la barra espaciadora 00:46:21

ya todos los fotogramas me pone cuántos tienen. 00:46:23

Le vuelvo a dar y sale. 00:46:25

Yo quiero solo que se ejecute 00:46:27

en un momento, aunque esté en el update, 00:46:29

solo en el momento que se ejecuta 00:46:31

en ese fotograma que se ejecuta esta acción. 00:46:33

¿Se entiende esto? 00:46:35

Es importante ir viendo 00:46:39

en dónde vamos 00:46:41

los bloques que vamos a generar. 00:46:43

Estos bloques son esenciales, porque si no 00:46:45

nos volvemos un poco locos. 00:46:47

Entonces ya hemos generado el primer 00:46:49

impacto. La gracia 00:46:51

de un juego como este 00:46:53

quizás sea que 00:46:55

el número del impacto 00:46:57

ha puesto 00:46:59

un compañero. Cada bloque es como un programita 00:47:01

aparte. 00:47:03

Sí, es como 00:47:05

una frase aparte. 00:47:07

Sí, como compartimentos. 00:47:09

Igual que aquí hablo de cajas, 00:47:11

pues luego estas cajas 00:47:13

también hay como compartimentos 00:47:15

estancos. Entonces hay que ir 00:47:17

evaluando todo según el compartimento en el que está. 00:47:19

Además, estos son matrioscas. 00:47:21

Matrioscas, sí, las muñecas 00:47:23

que se van a meter una dentro de otra. 00:47:25

Pues eso, hay que ir viendo qué se mete dentro de qué. 00:47:27

Lo que os decía, 00:47:29

la gracia... 00:47:31

Un segundín... 00:47:33

Yo tengo una chuleta por aquí que así me pierdo 00:47:35

menos. 00:47:37

La gracia de esto es que 00:47:39

el impacto 00:47:41

se vaya generando de manera aleatoria. 00:47:43

Es decir, que no siempre valga 40, porque si no el juego 00:47:45

es muy predecible. 00:47:47

Aquí ya es cuando vamos metiendo más 00:47:49

instrucciones, que es lo que vamos a ir 00:47:51

aprendiendo a lo largo del curso. Como por ejemplo, 00:47:53

en vez de yo poner aquí 40, 00:47:55

hay otra clase 00:47:57

y otra operación que nos permite 00:47:59

generar números aleatorios. 00:48:01

Para eso, 00:48:03

esto lo digo aquí que 00:48:05

creo que en el enunciado 00:48:07

no lo ponía. 00:48:09

Creo que sí que lo ponía en los... 00:48:13

Bueno, aquí os pone lo de crear la 00:48:17

variable booleana para 00:48:19

tener claro 00:48:21

si está vivo o no. 00:48:23

Porque, ojo, 00:48:25

y voy a hacer una cosa antes de 00:48:27

pasar al otro. Aquí podemos 00:48:29

meter más condiciones, que esto lo ponía en el tema 00:48:31

cero también. Luego podemos 00:48:33

ir concatenando condiciones. 00:48:35

Si yo aquí pongo, cuando pulse 00:48:37

la tecla espacio y aparte el personaje 00:48:39

esté vivo, 00:48:41

si el personaje está vivo 00:48:43

o si vivo igual a 00:48:45

true, 00:48:47

entonces sí se ejecuta. 00:48:49

¿Qué significa esto? Que si en algún momento muriera, 00:48:51

como esto pasaría 00:48:53

a valer falso, 00:48:55

esta condición no se estaría 00:48:57

toda completa 00:48:59

ejecutando, 00:49:01

dando 00:49:03

un verdadero de respuesta. 00:49:05

No se estaría cumpliendo la condición. 00:49:07

Si este personaje muriera, esto ya, 00:49:09

por mucho que demos a la barra espaciadora, una condición sí se 00:49:11

cumple, pero la otra no. 00:49:13

Aquí, 00:49:15

dentro de estos paréntesis, podemos meter múltiples condiciones. 00:49:17

Esto, para cuando 00:49:19

le echéis un ojo, 00:49:21

en el tema, 00:49:23

en el primer tema, 00:49:25

hay una sección 00:49:29

que es en estructurar de control, 00:49:31

que es donde estamos viendo estas cosas, 00:49:33

que habla de las 00:49:35

concatenaciones de... 00:49:37

Vale, aquí. 00:49:39

Por eso, si tienen 00:49:41

que darse a dos circunstancias separadas por i, 00:49:43

en este caso, 00:49:45

se tiene que dar tal. Por ejemplo, aquí, 00:49:47

es parte del enunciado 00:49:49

de esta 00:49:51

tarea, que se pueden usar 00:49:53

estas partes. Aquí, si el impacto 00:49:55

es menor o igual a la energía, y aparte, 00:49:57

además, el escudo 00:49:59

es falso, se realiza 00:50:01

esto que hay aquí. 00:50:03

Entonces, hay que ir 00:50:05

pensando en estos paréntesis 00:50:07

como, digamos, 00:50:09

una recopilación de condiciones 00:50:11

que se pueden dar, que pueden ser 00:50:13

múltiples, que os suene eso. 00:50:15

Entonces, yo cuando... 00:50:17

Ahora mismo no va a haber ningún problema porque está vivo, 00:50:19

pero fijaos también 00:50:21

algo importante, que es que esto de vivo, 00:50:23

ahora el true, en vez de hacerlo 00:50:25

como aquí, tiene dos paréntesis. 00:50:27

Dos iguales, pero nada. 00:50:29

¿Por qué a veces hay dos 00:50:31

de cada tipo? Por decirlo así. 00:50:33

Bueno, no siempre es así. 00:50:35

El otro día vimos que para sumar una 00:50:37

variable, 00:50:39

podíamos usar el más más o el menos menos. 00:50:41

Aquí no es lo mismo que voy a explicar. 00:50:43

Pero bueno, que hay distintos operadores, 00:50:45

que lo tenéis todos en ese tema, o al menos 00:50:47

los esenciales. Pero cuando estamos 00:50:49

dentro de los condicionales, 00:50:51

lo que queremos hacer no es asignar un valor, 00:50:53

no queremos que vivo pase a ser true 00:50:55

o escudo pase a ser 100, 00:50:57

o que vivo pase a ser true en este caso. 00:50:59

No, lo que queremos es hacer una comparación. 00:51:01

Cuando queremos 00:51:03

hacer comparaciones, 00:51:05

se duplican los signos. 00:51:07

Creo que en todos, de hecho. 00:51:09

Si queremos que si vivo 00:51:11

es igual a true, 00:51:13

aquí sí que es igual a. 00:51:15

No es como aquí, que es asigno algo. 00:51:17

Luego hay otro, que es 00:51:19

si vivo es diferente a 00:51:21

true, que es este operador 00:51:23

que tenemos aquí, y que en el tema 00:51:25

también tendréis 00:51:27

operadores seguramente. 00:51:29

Una parte 00:51:31

que tenía más operadores, 00:51:33

estructuras... 00:51:35

Aquí tiene que estar... 00:51:37

Aquí tenéis donde explica el i o el o, 00:51:39

para que se ejecute solo una 00:51:41

de las dos condiciones. 00:51:43

Pero también tiene que haber 00:51:45

en algún momento que os hable de las... 00:51:47

Bueno, aquí os dice que se usa para asignar 00:51:49

una variable un solo igual. Aquí tenéis 00:51:51

explicado esto también. Y aquí tenéis 00:51:53

lo del inverso, el diferente, 00:51:55

que para eso se usa 00:51:57

la exclamación. 00:51:59

Entonces, cuando ponemos un 00:52:01

exclamación igual, significa 00:52:03

que es diferente de. Si tenemos 00:52:05

igual, es igual. 00:52:07

Básicamente, si ponemos esto, es 00:52:09

si pulsamos la tecla espaciadora 00:52:11

y abarte vivo es diferente a true, 00:52:13

que como es una booleana solo admite dos valores, 00:52:15

si vivo es 00:52:17

falso, se ejecuta esto. 00:52:19

Ahora mismo, básicamente 00:52:21

lo que conseguiría es que 00:52:23

como no se está cumpliendo la condición, 00:52:25

yo voy al juego y por mucho que ahora le dé 00:52:27

a la barra espaciadora, 00:52:29

yo le empiezo a dar y no se cumple, 00:52:31

porque está vivo 00:52:33

y como la condición tiene que cumplirse, 00:52:35

si no está vivo, si no es 00:52:37

verdadero, pues esto 00:52:39

no se va a ejecutar nunca. 00:52:41

Que ojo 00:52:43

a los comparadores. 00:52:45

Ahora vamos 00:52:47

a ver también que como comparadores 00:52:49

están el igual y luego están 00:52:51

el menor igual, 00:52:53

el mayor igual, etc. 00:52:55

Eso lo tenéis explicado por aquí. 00:52:57

Se puede poner que algo sea 00:52:59

menor o mayor o menor e igual. 00:53:01

Eso lo vamos a ver ahora 00:53:03

en otro contexto. 00:53:05

¿Hasta aquí qué tal? 00:53:07

Lo que os decía, 00:53:13

y esto voy a ir rápido porque 00:53:15

ya lo veremos más adelante, pero a nivel 00:53:17

está bien, cuando queramos 00:53:21

generar valores aleatorios 00:53:23

hay una 00:53:25

clase que es random, de aleatorio, 00:53:27

y dentro de la clase random 00:53:29

tenemos todas 00:53:31

estos métodos. 00:53:33

Hay uno que es random 00:53:35

dentro de un rango de números. 00:53:37

Si me pongo aquí, devuelve un 00:53:39

float, un número 00:53:41

con decimales, 00:53:43

aleatorio, dentro de 00:53:45

un rango. Yo quiero que 00:53:47

el impacto 00:53:49

pueda estar entre, 00:53:51

aquí igual que hacíamos en el Instantiate, 00:53:53

básicamente cuando declaramos 00:53:55

otra vez, me resulta muy 00:53:57

importante que vayáis intentando 00:53:59

entender qué pone. Fijaos en lo 00:54:01

que pone aquí la sobrecarga, que es 00:54:03

dentro se pone el mínimo, incluido 00:54:05

ese dentro del rango, y el máximo del rango. 00:54:07

Yo lo que pongo aquí 00:54:09

básicamente es que cuando 00:54:11

yo ejecute este método, 00:54:13

voy a hacer que 00:54:15

cada vez que se pulse la tecla espaciadora 00:54:17

en el valor impacto se va a guardar 00:54:19

una cifra que 00:54:21

esté entre 0 y 40, 00:54:23

por ejemplo. A veces valdrá 00:54:25

0, a veces valdrá 30, a veces valdrá 00:54:27

10, y cada vez valdrá una cosa. 00:54:29

Y según lo que guarde aquí, como 00:54:31

está ejecutándose y se ha guardado en impacto, 00:54:33

lo que resta del escudo va a ser 00:54:35

diferente. Guardo 00:54:37

y ejecuto. Y vais a ver ahora que el mensaje 00:54:39

se va 00:54:41

a 00:54:43

ir mostrando 00:54:45

y la resta de energía va a ir variando. 00:54:47

96 de escudo, 78, 00:54:49

43, porque cada vez está restando 00:54:51

un valor distinto. 00:54:53

Algo importante, por ejemplo, en la tarea 00:54:57

2, que tenéis que ir generando obstáculos 00:54:59

en el eje X, pero no queréis 00:55:01

que esos obstáculos vayan apareciendo todo el rato 00:55:03

en el mismo punto, entonces tendréis que ir 00:55:05

aleatorizando las cifras. 00:55:07

Pues el Random Rate 00:55:09

es un gran 00:55:11

método para conseguir esto. 00:55:13

Lo primero, voy a poner aquí 00:55:15

un espacio para que no aparezca lo de antes 00:55:17

y guardo. Ahora ya tenemos 00:55:19

conseguido que si 00:55:21

la nave va siendo golpeada, pues 00:55:29

un mensaje nos va diciendo cuánto va quedando 00:55:31

de escudo. 00:55:33

Hasta aquí más o menos me vais siguiendo. 00:55:35

¿Qué vamos a hacer ahora? 00:55:41

En el Update, aparte de 00:55:43

darnos la 00:55:45

posibilidad de pulsar la tecla espaciadora y que haya 00:55:47

impacto, lo que vamos a ir haciendo es 00:55:49

poner condiciones 00:55:51

que terminen 00:55:53

si se van sumando, restando vidas. 00:55:55

Ahora mismo seguimos 00:55:57

restando escudo, se vuelve a valores 00:55:59

negativos y así podemos estar hasta 00:56:01

el infinito. Habrá que decir en algún momento 00:56:03

que si llega a 0 o menos 00:56:07

pues restes una vida. 00:56:09

Para eso, 00:56:11

vamos a hacer otra condición. 00:56:13

Esto es igual, se pueden meter condiciones 00:56:15

dentro de condiciones. Yo aquí podría poner 00:56:17

un if de si se ejecuta 00:56:19

esto, aparte, si también se ejecuta 00:56:21

otra cosa, pues seguirá reproduciéndose. 00:56:23

Aquí, si lo voy poniendo 00:56:25

a niveles 00:56:27

análogos, es decir, que no está ninguna dentro 00:56:29

de otra, primero comprueba que esta se cumpla 00:56:31

en el fotograma. ¿Se cumple? Sí. 00:56:33

Ejecútalo aquí. ¿Que no? 00:56:35

Paso a lo siguiente. Si lo siguiente es un if otra 00:56:37

vez, 00:56:39

pues volveré a 00:56:41

ejecutarlo, que esté entre las llaves. 00:56:43

Y aquí vamos a decir que 00:56:45

si el impacto 00:56:47

es 00:56:49

y ahora vais a ver que da un problema, 00:56:51

mayor 00:56:53

o igual 00:56:55

a el escudo 00:56:57

que queda, pues 00:56:59

lo pongo así, pero bueno, 00:57:01

se le resta una vida. 00:57:03

Porque básicamente, si el impacto 00:57:05

es una cantidad 00:57:07

mayor que lo que queda de escudo, 00:57:09

nos hemos cargado a la nave, por tanto 00:57:11

tenemos una vida. 00:57:13

¿Por qué 00:57:15

puede dar esto 00:57:17

problemas o no? 00:57:19

¿Qué está pasando aquí? 00:57:21

Básicamente, lo que estamos haciendo es 00:57:23

que se está ejecutando esto 00:57:25

e impacto se está 00:57:27

digamos 00:57:29

calculando 00:57:31

dentro de cuando pulsemos la tecla. 00:57:33

Entonces, si cada fotograma 00:57:35

está comprobando que impacto 00:57:37

sea mayor o menor que escudo, 00:57:39

al final lo que va a ir haciendo es 00:57:41

comprobando si en cada momento 00:57:43

impacto tiene 00:57:45

mayor que escudo. 00:57:47

Entonces, nosotros esto no queremos que 00:57:49

esté evaluándolo continuamente. 00:57:51

Queremos que la operación de sumar o restar vida 00:57:53

nuevamente se dé una vez 00:57:55

se ha dado esta condición. Por tanto, 00:57:57

si al pulsar esta tecla 00:57:59

se ejecuta esto 00:58:01

y, oye, que impacto es mayor 00:58:03

que escudo, pues entonces le restamos una vida. 00:58:05

Si no, da igual, porque no voy a estar todo el rato 00:58:07

restando vida. 00:58:09

Entonces, lo meto todo para que esté dentro 00:58:11

de este mismo IF. 00:58:13

Y recordad del otro día que dijimos 00:58:15

si impacto es mayor o igual a escudo, 00:58:17

pues de las vidas que tengo, 00:58:19

que tengo 3, vida en nave 3, 00:58:21

pues yo le voy a restar 1. 00:58:23

Y esto el otro día igual, vimos varias formas 00:58:25

de hacerlo. A ver, lo tabulo 00:58:27

para que se vea mejor. Tabular 00:58:29

sirve para ir marcando 00:58:31

con la tecla tabulador. A veces 00:58:33

lo hace de manera automática, incluso hay 00:58:35

casos de que lo tabule todo automáticamente, 00:58:37

pero bueno, con la tecla tabulador podemos ir 00:58:39

dando tabulaciones. Lo suyo es 00:58:41

a medida que vamos metiéndonos 00:58:43

dentro de bloques, 00:58:45

vayamos tabulando para que visualmente 00:58:47

veamos a nivel 00:58:49

vertical qué está 00:58:51

dentro de qué, porque si no esto 00:58:53

se va convirtiendo en muy confuso. 00:58:55

Aquí, si cuando hemos generado 00:58:57

este impacto y se resta de escudo, 00:58:59

si el impacto que tenemos 00:59:01

aquí generado ha sido mayor 00:59:03

que el escudo que queda, 00:59:05

pues entonces 00:59:07

la vida de la nave tiene que ser igual 00:59:09

a vidas nave 00:59:11

menos 00:59:13

una. 00:59:15

Pasaría a 00:59:17

valer una menos de las que tiene. 00:59:19

Recordad que el otro día os dije 00:59:21

que esto mismo que aquí se puede 00:59:23

escribir, esto mismo se puede 00:59:25

escribir, lo comento, 00:59:27

vidas nave 00:59:29

menos igual 00:59:31

uno 00:59:33

en este caso. 00:59:35

Aquí podría poner otra variable 00:59:37

si fuera otra. 00:59:39

En el fondo es lo mismo que aquí 00:59:41

podríamos hacerlo. Lo estoy poniendo 00:59:43

en este ejemplo, 00:59:45

pero aquí también podríamos, por ejemplo, 00:59:47

resumirlo para que sea 00:59:49

más directo como esto. 00:59:51

Son exactamente lo mismo. 00:59:53

Y luego 00:59:55

cuando va de uno en uno, también 00:59:57

esto es igual, que en este 00:59:59

caso no tiene sentido, pero aquí sí, también puede ser 01:00:01

igual que escribir, 01:00:03

lo comento para que no se ejecute, 01:00:05

que poner vidas 01:00:07

nave menos menos. 01:00:09

Por eso el menos menos y el más más 01:00:11

se usan mucho porque 01:00:13

cuando son operaciones 01:00:15

de sumo uno bajo uno, por ejemplo, 01:00:17

la vida se va de una en una normalmente, 01:00:19

pues existen estos operadores. 01:00:21

Si el impacto es mayor que lo que quedaba de escudo 01:00:23

en este momento que se ha ejecutado, 01:00:25

pues se restará una vida. 01:00:27

Si se olvida nave, pasaría a valer dos. 01:00:29

Es decir, 01:00:31

vamos a hacerlo de una forma 01:00:33

más rápida. 01:00:35

Aquí voy a mostrar 01:00:37

en consola, nuevamente para que se vaya 01:00:39

viendo todo lo que vamos haciendo, 01:00:41

que cuánto vale 01:00:43

me quedan 01:00:45

con cateno 01:00:51

el número de vidas que le queda a nave. 01:00:53

Vale, me quedan 01:00:55

no sé cuántas vidas. 01:00:57

Esto ya entiendo que vais 01:00:59

entendiendo la concatenación de textos. 01:01:01

¿Esto qué significa? 01:01:03

De nuevo, sólo se va a ejecutar 01:01:05

cuando 01:01:07

impacto, cuando el daño 01:01:09

que hace el meteorito 01:01:11

sea mayor que el escudo. 01:01:13

Si no, no se va a mostrar este mensaje. 01:01:15

Es decir, primero tenemos que dar a la barra espaciadora 01:01:17

para que se dé el impacto 01:01:19

y aparte que compruebe si el impacto es mayor 01:01:21

que el escudo. Nuevamente, 01:01:23

no es lo mismo tener un if dentro 01:01:25

de otro que dejarlo fuera 01:01:27

de otro. 01:01:29

Vamos a ver un poco 01:01:31

cómo se desarrolla esto. 01:01:33

Le doy a la barra espaciadora. 01:01:35

A ver... 01:01:37

Creo que no ha guardado. 01:01:39

Ahí está. 01:01:41

Escudo menos impacto. 01:01:43

Sí, está bien. 01:01:45

Si no me equivoco... 01:01:47

Voy aquí. 01:01:49

Estoy aquí. 01:01:51

Le doy a la barra espaciadora. 01:01:53

Y ojo que no se está ejecutando. 01:01:55

Hay que ver el por qué. 01:01:57

Vale. 01:01:59

¿Por qué 01:02:03

se provoca? Estoy vivo. 01:02:05

Estoy vivo. 01:02:07

En teoría, 01:02:09

debería ir. 01:02:11

Ta, ta, 01:02:13

y ta. 01:02:15

Sí. 01:02:17

Por eso es la barra espaciadora. 01:02:19

Estoy vivo, que empieza estando vivo. 01:02:21

El impacto se genera aquí. 01:02:23

Y escudo 01:02:25

menos impacto. 01:02:27

La nave tiene tal. 01:02:29

¿Y por qué 01:02:31

no se está viendo? 01:02:33

Estas cosas a veces pasan 01:02:35

y hay que 01:02:37

ver cómo resolverlas. 01:02:39

¿Está asignado el script? Sí. 01:02:41

Pues a ver... 01:02:43

Vale. Cuando pasan 01:02:45

estas cosas... 01:02:47

Bueno, no sé si lo parece o no, 01:02:49

pero parece que estoy haciendo algo y no me sale 01:02:51

porque hasta que no compruebo... 01:02:53

Ojo, que si estáis haciendo operaciones 01:02:55

y no funciona, a veces es porque 01:02:57

tenéis seleccionada la ventana de escena. 01:02:59

Para que todo se ejecute, pinchar 01:03:01

en la de Game, porque si no, no se ejecuta. 01:03:03

Ahora, cada vez que le voy dando, se va restando. 01:03:05

¿Veis que solo pone el mensaje 01:03:07

que la nave tiene tanto escudo y todavía no ha puesto 01:03:09

nada de me quedan no sé cuántas vidas? 01:03:11

Sigo jugando. Cuando llegue 01:03:13

a cero o menos, 01:03:15

tiene 22 de escudo. 01:03:17

Y ahora me pone 01:03:19

me quedan dos vidas. Primero, aquí hay 01:03:21

un espacio que no he puesto. 01:03:23

Y hay un error de concepto 01:03:25

también, que es si el impacto 01:03:27

es mayor que el escudo, 01:03:29

me ponga eso. Pero el problema está en que 01:03:31

el impacto 01:03:33

se ha restado del escudo en este momento, 01:03:35

pero a veces no tiene por qué 01:03:37

haber matado a la nave. 01:03:39

Entonces, 01:03:41

igual que tengo que hacer esto, 01:03:43

vuelvo a ejecutar porque 01:03:49

el problema que tenemos aquí, 01:03:51

empieza a dar 01:03:53

plus, plus, plus, 01:03:55

26. 01:03:57

Y cuando tiene 01:03:59

más cantidad 01:04:01

que la que tiene, es que está mal formulado 01:04:03

esto, porque en realidad, pensadlo, 01:04:05

que el impacto 01:04:07

tiene que ser mayor que la 01:04:09

energía. Pero es que, 01:04:11

si aquí es 01:04:13

38 y de 01:04:15

escudo tenía 36, 01:04:17

pues aquí se queda con 36, 01:04:21

pero entonces no nos está enseñando 01:04:23

esto. Por tanto, ¿qué significa esto? 01:04:25

Que el impacto, 01:04:27

esto que estamos poniendo aquí, 01:04:29

si el impacto es mayor 01:04:31

que el escudo, 01:04:33

lo ponemos aquí. 01:04:35

Si el impacto es mayor 01:04:37

de lo que queda de escudo, 01:04:39

pues ya estoy muriendo 01:04:41

y me restas una vida. 01:04:43

Y entonces, luego al escudo le restamos 01:04:45

lo que hay que hacer. Es decir, ya en ese 01:04:47

momento ya nos va a dar igual lo que ponga en el escudo 01:04:49

porque básicamente nos hemos cargado una vida. 01:04:51

Entonces, 01:04:53

si el impacto es mayor que el escudo, 01:04:55

me restas una vida y me dices 01:04:57

que esto, que ya estoy muerto 01:04:59

y me ha quitado una nave. 01:05:01

Y si no, 01:05:03

y ahora vemos esto, si no, si 01:05:05

escudo 01:05:07

es 01:05:09

mayor, si impacto 01:05:11

es menor 01:05:13

o igual, 01:05:15

estoy poniendo al revés, 01:05:17

menor o igual que escudo, 01:05:19

pues simplemente 01:05:21

lo que va a hacer es 01:05:23

enseñarnos esto que tenemos 01:05:25

aquí. 01:05:27

A ver. 01:05:29

No sé si estáis entendiendo lo que estoy haciendo. 01:05:31

Y aparte, aquí hay una 01:05:33

incoherencia que ahora vemos, que es que 01:05:35

aquí ponemos impacto es igual que escudo 01:05:37

e impacto es igual que escudo. 01:05:39

Uno de los dos no puede tener ese igual. 01:05:41

A ver. 01:05:43

Hasta aquí, ¿qué tal me vais 01:05:45

siguiendo? Ahora vemos el resultado. 01:05:47

Pero vamos a analizar 01:05:49

ahora mismo qué es lo que estamos haciendo. 01:05:51

A ver, espera que 01:05:53

tengo que meterme aquí para leeros 01:05:55

si no me habláis. Un poco confuso. 01:05:57

Sí. 01:05:59

Vamos a ello. Vamos a verlo. 01:06:01

Para llegar a estas cosas a veces hay que dar vueltas, ¿vale? 01:06:03

No es directo. Entonces esto también me sirve 01:06:05

para verlo. Lo que estamos haciendo 01:06:07

aquí es asignamos, 01:06:09

arrancamos el juego, tiene tanta 01:06:11

energía, está todo para empezar 01:06:13

a jugar. Cada fotograma está comprobando 01:06:15

si damos a la barra espaciadora 01:06:17

y si estamos vivos. 01:06:19

Que por defecto, hasta que no digamos 01:06:21

lo contrario, le estamos diciendo que es verdadero. 01:06:23

Se cumple la función. 01:06:25

Y según le hemos dado a esta 01:06:27

en ese momento, sólo una vez, 01:06:29

porque es cuando pulsamos la tecla down, 01:06:31

impacto calcula que vale 01:06:33

una cifra. 01:06:35

Entonces, a partir de aquí, 01:06:37

hay que hacer dos comprobaciones. 01:06:39

Si ese impacto que se ha generado 01:06:41

es mayor o igual que el escudo, 01:06:43

yo no quiero que me demuestre 01:06:45

cuánto escudo queda, 01:06:47

porque no va a ser 01:06:49

positivo, 01:06:51

va a ser negativo. 01:06:53

Es decir, si queda 01:06:55

20 de escudo y el impacto es 38, 01:06:57

no quiero que me ponga menos 12, 01:06:59

quiero que directamente me reste una vida 01:07:01

y me diga, oye, 01:07:03

te han quitado una vida. 01:07:05

Te han quitado una vida. 01:07:07

Te quedan 01:07:09

y aquí, digamos que 01:07:11

te resta una vida y te demuestra. 01:07:13

Pero, claro, si eso, 01:07:15

vuelvo a decirlo, 01:07:17

no quiero que me 01:07:19

reste escudo. 01:07:21

Lo que quiero es que me quite una vida, 01:07:23

no quiero que me lo deje en menos 100. 01:07:25

Entonces, lo que estamos haciendo aquí es 01:07:27

si impacto es mayor que escudo, 01:07:29

me restas una vida y me dices cuántas vidas quedan. 01:07:31

Y además, 01:07:33

importante, habrá que decirle que el escudo 01:07:35

pase a valer 01:07:37

100 de nuevo, porque empezaremos 01:07:39

una nueva partida, y si el impacto 01:07:41

no era mayor que el escudo, es decir, 01:07:43

si el impacto es menor que el escudo, 01:07:45

lo que vamos a hacer es a escudo restarle 01:07:47

un impacto y enséñame cuánto 01:07:49

escudo tiene la nave. 01:07:51

¿Sí? 01:07:53

Entonces, ahora mismo, 01:07:55

básicamente, lo que 01:07:57

hacemos cuando arrancamos el juego 01:07:59

es que empezamos 01:08:01

a jugar, le damos 95. 01:08:03

Bueno, 01:08:05

tened en cuenta que también puede ser 0 el valor, 01:08:07

lo hemos puesto en un rango que 0 también está. 01:08:09

Seguimos, seguimos, ahora están siendo 01:08:11

pequeñas, ¿vale? Y ahora seguramente 01:08:13

cuando le dé, me dice 01:08:15

te han quitado una vida, te quedan dos vidas, porque 01:08:17

el impacto era mayor de 10, entonces 01:08:19

pues ya, como no queremos que sea 0, 01:08:21

pues 01:08:23

nos resta una vida 01:08:25

y pasaríamos a tener dos vidas. 01:08:27

Y el juego, además, el escudo 01:08:29

vuelve a estar 100 para volver otra vez 01:08:31

a jugar al bucle. 01:08:33

¿Sí? 01:08:35

Vale. Esto que he hecho 01:08:39

aquí, simplemente para que os suene, 01:08:41

tened en cuenta que una condición y otra 01:08:43

están vinculadas, es decir, si ésta se cumple 01:08:45

bien y si no, 01:08:47

si no, este else sirve para eso, 01:08:49

si no, si se cumple esta nueva 01:08:51

condición, vale. Esta condición 01:08:53

nunca se va a llegar a reproducir 01:08:55

si ésta sí se cumple, ¿no? 01:08:57

Pero veis que en este caso las dos son 01:08:59

complementarias, es decir, 01:09:01

puede ser mayor o igual, por eso he 01:09:03

quitado el igual en uno, porque es que si no la condición 01:09:05

en cierto modo estaba coincidiendo. 01:09:07

Si el impacto es igual a lo superior 01:09:09

se ejecuta y si no es, pues 01:09:11

lo que resta, que es la otra opción. 01:09:13

Cuando... Esto se pueden ir concatenando 01:09:15

distintos else if. Puede haber, por ejemplo, 01:09:17

si el rango de edad de una persona 01:09:19

es de 0 a 16 años, pues 01:09:21

se la califica como menor. Si es de 16 01:09:23

a... Si no, si es de 01:09:25

16 a... 01:09:27

O mejor dicho, de 17 a 25 01:09:29

es joven. Si es de 26 01:09:31

a 80 es viejo, ¿vale? Pues se 01:09:33

puede... o anciano. Se pueden ir haciendo 01:09:35

distintos rangos. Si va a ser 01:09:37

una condición en la que todo lo que 01:09:39

no sea esto, sea lo otro, 01:09:41

se puede poner simplemente sin una 01:09:43

condición así, else 01:09:45

y pone, si esto se cumple, se ejecuta 01:09:47

esto y ya está, 01:09:49

porque esto ya no... Si no, 01:09:51

no tiene sentido, es decir, 01:09:53

se está ejecutando esto y de aquí pues ya 01:09:55

pasamos, porque ya se ha cumplido 01:09:57

la primera parte. Pero si esta 01:09:59

condición no se cumple, 01:10:01

digamos aquí, pues entonces 01:10:03

repinablemente se tiene que ejecutar esta. 01:10:05

Que no es lo mismo que poner otra condición 01:10:07

como acababa de hacer aquí. 01:10:09

¿Vale? Entonces 01:10:11

digamos que podemos ir concatenando 01:10:13

también condiciones para 01:10:15

que si no se cumple otra, 01:10:17

se cumple la siguiente. Y si no, pues se puede 01:10:19

cumplir la siguiente. Y si ninguna se cumple, 01:10:21

pues ya está, 01:10:23

doy otro valor. 01:10:25

Entonces con estos ifs podemos 01:10:27

ir, y los else ifs, 01:10:29

podemos ir condicionando un poco 01:10:31

lo que va ocurriendo en todo momento. 01:10:33

¿Sí? ¿Me seguís? 01:10:35

Vale. 01:10:37

Entonces, 01:10:39

tenemos aquí el impacto 01:10:41

que se genera cuando le damos a la tecla 01:10:43

a la tecla 01:10:45

a la tecla 01:10:49

barra espaciadora, sí. 01:10:51

¿Vale? Si luego 01:10:53

además dentro de esto 01:10:55

digamos que ha perdido 01:10:59

una vida, ¿vale? 01:11:01

Tenemos que decir, oye, te quedan no sé cuántas 01:11:03

vidas, pero es que, ojo, 01:11:05

si las vidas que quedan 01:11:07

son 01:11:09

a ver un segundo 01:11:11

menores o iguales a cero 01:11:13

o básicamente cero 01:11:15

porque va a ir pasando por todas, ¿vale? 01:11:17

Es decir, como va restando de una en una en este 01:11:19

momento, pues no es posible 01:11:21

que pase de uno a menos uno. Entonces si 01:11:23

vidas llegase a cero en algún momento, 01:11:25

recordad que para condicionales hay que 01:11:27

poner doble signo, ¿vale? 01:11:29

Para igual, ¿vale? Pues entonces 01:11:31

se ejecuta esta línea. 01:11:33

Ahora vemos si esto tiene sentido. 01:11:35

Que no lo va a tener, pero vamos 01:11:37

viendo un poco la lógica. 01:11:39

Si vidas, 01:11:41

perdón, no sé por qué he puesto lives, 01:11:43

si vidas nave es igual a cero, te han quitado 01:11:45

una vida. No, realmente esta frase yo 01:11:47

quiero que me la enseñe siempre que se resta la vida 01:11:49

para yo ir sabiendo cuántas vidas 01:11:51

me quedan, ¿vale? Aquí si 01:11:53

llegara a cero, ¿vale? 01:11:55

Lo que quiero es que me ponga un mensaje de, oye, 01:11:57

están muertos, vidas 01:11:59

de backlog. 01:12:01

Como dice, tiene cero 01:12:05

vidas, ha llegado ese momento, ¿tienes? 01:12:07

Incluso no hace falta ni poner 01:12:09

la referencia vida-nave, porque sabes que en este 01:12:11

caso tiene cero vidas, ¿no? 01:12:13

Tiene cero vidas, han muerto, 01:12:15

¿vale? Y aquí he puesto una condición de 01:12:17

escudo 100, ¿no? Cuando pierdes 01:12:19

toda la vida y estás muerto, no quieres que la nave 01:12:21

digamos se resete con otra vida y otro 01:12:23

escudo. Nuevamente habría que ponerlo aquí. 01:12:25

Esto significa que este if, 01:12:27

siempre que se cumpla, siempre que muramos, 01:12:29

una vida se resta, y si 01:12:31

además esa vida es la que ya es 01:12:33

cero, pues han muerto, ¿vale? 01:12:35

Y aquí te dice, oye, que has acabado 01:12:37

de morir, ¿vale? 01:12:39

Ahí está. Si no, 01:12:43

si el impacto es menor que el escudo, 01:12:45

es decir, que no llega a matar el escudo por 01:12:47

completo, pues guardamos en la variable 01:12:49

escudo la operación de restarle 01:12:51

impacto, y vamos a ir en 01:12:53

todo momento, pues, 01:12:55

viendo cuánto queda. 01:12:57

Entonces, más o menos, 01:12:59

vamos a ir 01:13:01

viendo si el juego funciona, ¿vale? 01:13:03

Y a ver si podemos llegar a las 01:13:05

tres vidas, 01:13:07

y cuando tiene cero vidas, han muerto, 01:13:09

es que ha acabado el juego. 01:13:11

Entonces vamos a hacer un juego que está 01:13:13

todo el rato valorando 01:13:15

si estamos restando vidas o estamos 01:13:17

quitando vidas, restando vidas o 01:13:19

quitando escudo, según 01:13:21

si el impacto o el escudo 01:13:23

son mayor o menor entre sí. 01:13:25

Entonces, vamos a ver 01:13:27

este juego cómo funciona. 01:13:29

Le doy aquí al play 01:13:31

y empezamos. Empezamos 01:13:33

con cien y tres vidas, ¿no? Le damos a play, 01:13:35

a barra 01:13:37

espaciadora, perdón, y empieza 01:13:39

a restar, empieza a restar, empieza a restar, 01:13:41

¿vale? Y cuando ya el escudo se 01:13:43

vaya, te han quitado una vida, te quedan dos vidas. 01:13:45

Y se ha recargado en este momento 01:13:47

a cien el escudo, dos vidas, cien. 01:13:49

Vuelvo a darle, la nave tiene 01:13:51

ocho escudos, cuarenta y cinco, quince. 01:13:53

Te han quitado una vida, te quedan una vida. 01:13:55

Bueno, ese habría que solucionar 01:13:57

que cuando queda solo una vida, también el mensaje 01:13:59

pues quitará la S, se podría ir depurando, ¿no? 01:14:01

Vuelvo a darle, empiezo 01:14:03

de cien otra vez, ochenta y siete, ochenta y dos, 01:14:05

cuarenta y siete, treinta y dos, y aquí 01:14:07

te han quitado una vida, te quedan cero vidas, 01:14:09

pues tienes cero vidas, ya has muerto. 01:14:11

¿Vale? Este mensaje de te han quitado 01:14:13

una vida, ¿vale? 01:14:15

Te han quitado una vida, si 01:14:17

podemos hacer que lo enseñe 01:14:21

siempre que no sea 01:14:23

igual a cero, ¿no? Ahora mismo 01:14:25

siempre te lo va a enseñar aunque sea cero. 01:14:27

Si 01:14:29

podemos hacer, fijaos que 01:14:31

ahora me surge una nueva necesidad, ¿no? 01:14:33

Y esto lo planteamos otra vez 01:14:35

como lenguaje humano. Si 01:14:37

y para que veáis 01:14:39

que esto se puede escribir de muchas formas. 01:14:41

¿Vale? Voy preparando un condicional y 01:14:43

meto entre llaves 01:14:45

lo que sé que voy a querer que ya esté 01:14:47

dentro de esa condicional. 01:14:49

¿Vale? Si 01:14:51

las vidas nave 01:14:53

son 01:14:55

mayores que cero, 01:14:57

es decir, que está vivo, 01:14:59

también se podría hacer así, ahora lo hacemos así. 01:15:01

Me enseñas, te han quitado una vida 01:15:03

y el escudo pasa a ser cien. 01:15:05

Si esto pasa a ser, si 01:15:07

por el contrario tiene cero vidas, 01:15:09

me enseñas que tiene cero vidas. 01:15:11

Lo que hemos conseguido, para ir depurando un poco 01:15:13

que hace cada paso, 01:15:15

ahora cuando vayamos pasándonos 01:15:17

el juego, voy haciéndolo rápido, 01:15:19

cuando voy llegando al final, 01:15:21

¿vale? Te va a 01:15:23

mostrar si tienes cero de vidas, 01:15:25

¿vale? Y la nave tiene dos de escudo 01:15:27

y esto me lo está enseñando. 01:15:29

La nave tiene... Ah, porque le he vuelto a dar 01:15:31

a ver, impacto 01:15:33

mayor... 01:15:35

Claro, aquí 01:15:37

efectivamente, mira, 01:15:39

aquí, aunque ya hayamos muerto, 01:15:41

yo puedo seguir pulsando y sigue 01:15:43

variando si impacto se ejecuta 01:15:45

o no, ¿vale? Lo que habría que hacer 01:15:47

para que ya, una vez moramos, 01:15:49

no siga haciendo este cálculo y por tanto 01:15:51

no nos siga mostrando mensajes, como que el juego 01:15:53

sigue existiendo, es donde podemos, por 01:15:55

ejemplo, meter en valor 01:15:57

esta booleana para que se cumpla. 01:15:59

Es decir, si yo muero, si las vidas 01:16:01

pasan a ser cero, aparte del mensaje, 01:16:03

vivo 01:16:05

pasará a ser falso. 01:16:07

Entonces, yo una vez 01:16:09

llegue a este punto 01:16:11

y en vida en nave pasa a ser cero, 01:16:13

el juego, básicamente, 01:16:15

como tal, deja de funcionar, porque yo ya 01:16:17

no puedo hacer la condición que estoy 01:16:19

ejecutando en todo momento 01:16:21

para que se realice la acción. 01:16:23

Entonces, con esta 01:16:25

booleana, por mucho 01:16:27

que yo ahora siga... Guardo 01:16:29

y vuelvo al editor. Por mucho que yo siga 01:16:31

dando a 01:16:33

la barra espaciadora, le doy rápido... 01:16:35

¿Vale? 01:16:37

Cuando llegue al punto de que me han 01:16:39

matado, por mucho que le de la barra espaciadora, 01:16:41

ya no pasa nada. Hasta que yo que sé, 01:16:43

en algún momento diga, vale, pero si le das 01:16:45

a la tecla 01:16:47

escape, lo podemos hacer. 01:16:49

A ver, aquí ya 01:16:51

empieza a liarse, ¿no? Cuando 01:16:53

marcáis un inicio de llave así, 01:16:55

os marca donde se cierra, ¿vale? 01:16:57

Ahora yo quiero hacer algo independiente 01:16:59

de esto, que es 01:17:01

voy a hacer otro input en el que 01:17:03

si... 01:17:05

¿Vale? Si yo 01:17:07

pulso, por ejemplo, la tecla 01:17:09

R, de reset, ¿vale? 01:17:11

Vuelvo a hacer lo mismo, solo quiero que sea 01:17:13

una vez cuando pulse la tecla. 01:17:15

GetKeyDown, ¿vale? 01:17:17

Y del KeyCode voy a querer que sea... 01:17:19

del KeyCode voy a poner, he dicho, la tecla R. 01:17:21

R, O, P, Q, R. Pues aquí la tenemos. 01:17:27

La damos y ahí está, esperando a que 01:17:29

hagamos algo. ¿Vale? Cuando yo pulse 01:17:31

la tecla R, y además, 01:17:33

no siempre, solo cuando 01:17:35

vivo sea 01:17:39

falso, 01:17:41

igual, 01:17:43

recordad que hay que poner el doble 01:17:45

igual, ¿vale? Siempre que vivo sea falso, 01:17:47

es decir, que esté muerto, porque si no, cada 01:17:49

vez que le diera R, estaría cambiando 01:17:51

el valor de vivo, pero yo solo quiero cambiarlo una vez 01:17:53

ha pasado a ser falso, ¿vale? 01:17:55

Lo que vamos a hacer es que en ese momento 01:17:57

vivo 01:17:59

va a pasar a valer 01:18:01

true. ¿Qué significa eso? 01:18:03

Que yo puedo pasarme el juego 01:18:05

y una vez muero, cuando le dé a la 01:18:07

R, si ya me he muerto, pues estoy 01:18:09

reiniciando el juego, ¿vale? Porque vuelve 01:18:11

a estar vivo. 01:18:13

No estoy reiniciando el juego como tal, porque habría 01:18:15

que resetear otra vez 01:18:17

la vida que tiene y el escudo, ¿vale? 01:18:19

Que se puede hacer aquí a continuación muy fácilmente, 01:18:21

pero 01:18:23

estoy diciendo que otra vez sea vivo 01:18:25

true y por tanto se pueda volver a cumplir 01:18:27

la condición, sino ya todo lo que hay aquí 01:18:29

en esta llave, toda esta parte, básicamente 01:18:31

la práctica totalidad de lo que 01:18:33

acabamos de programar, no se ejecuta. 01:18:35

Entonces con esto podemos 01:18:37

conseguir que vuelva a ser 01:18:39

true. Aparte habría que decir, 01:18:41

yo he muerto, he pasado a tener cero, 01:18:43

pues cuando le dé a la R, 01:18:45

voy a poner un mensaje 01:18:47

para que veáis. 01:18:49

Pongo 01:18:53

a ver... 01:18:55

Has reiniciado el juego. 01:18:57

Entonces hay que poner otra vez prácticamente 01:19:01

los valores que teníamos en el start, 01:19:03

que es otra vez volver a decir, 01:19:05

el vivo ahora lo borro, 01:19:07

volver a darle las condiciones de reinicio 01:19:09

del juego, que tenga otra vez 01:19:11

tres vidas y escudo. 01:19:13

Has reiniciado el juego, y ahí volvería 01:19:15

otra vez a ejecutarse el juego. 01:19:17

Aunque yo pulsara R 01:19:19

otra vez, según le doy, 01:19:21

como vivo no vuelve a ser falso, 01:19:23

es decir, he pasado a ser true y ya no se da esta 01:19:25

condición, hasta que no vuelva a morir, 01:19:27

esta operación no se ejecuta. 01:19:29

¿Vale? 01:19:31

¿Qué tal? ¿Hasta aquí me seguís? Ahora lo probamos, 01:19:33

pero me vais siguiendo. 01:19:35

¿Dudas que tengáis? 01:19:37

Me decís, por fa. 01:19:39

Esto es... 01:19:43

Más o menos, sí. Esto es de ir... 01:19:45

Incluso en un papel se puede ir escribiendo 01:19:49

y traduciendo esto al lenguaje de programación 01:19:51

que vamos teniendo. Pero veis que a veces 01:19:53

es confuso, porque hay que ir 01:19:55

probando y hay que ir cambiando el orden 01:19:57

de las cosas y las condiciones dentro de otra. 01:19:59

¿No se pone otra vez el número de vidas? 01:20:01

Exactamente. Aquí está. 01:20:03

Vida en nave pasa a ser otra vez tres. 01:20:05

¿Vale? 01:20:07

Entonces, 01:20:09

guardo, voy al editor, 01:20:11

y yo... 01:20:13

Empiezo a dar. Juego. 01:20:15

Voy dándole... 01:20:17

Tiene un escudo... 01:20:19

Vale, ya me han matado. 01:20:21

Me quedan dos vidas. Sigo. 01:20:23

Te han quitado una vida. ¿Te queda una? 01:20:25

Vale, sigo, sigo, sigo. 01:20:27

Tienes cero vidas. Has muerto. 01:20:29

Y sigo dándole la barra espaciadora y es que el juego ya... 01:20:31

Pondría un game over también. 01:20:33

Cuando sepamos más cosas, aquí habría que decir 01:20:35

en este momento de morir 01:20:37

que aparezca una nueva escena, que es la del 01:20:39

menú de game over. ¿Vale? Pero bueno, 01:20:41

de momento no sabemos, entonces hemos dicho 01:20:43

que como vivo 01:20:45

pasa a ser falso, 01:20:47

se cumple la condición de que si yo le doy a la R, 01:20:49

voy a reiniciar. Le doy a la R. 01:20:51

Blast. Ha reiniciado el juego. 01:20:53

¿Vale? Y ahora otra vez, 01:20:55

no estoy volviendo a ejecutar el juego, 01:20:57

no lo he parado. Sigo dándole y ahora 01:20:59

otra vez empezamos el juego. 01:21:01

Otra vez dos vidas, una vida, 01:21:03

vuelvo a morir. Sigo dando la barra espaciadora, 01:21:05

no pasa nada. Le vuelvo a dar a la R. 01:21:07

Ha reiniciado el juego. Y así, ya tenemos 01:21:09

un juego de bucle infinito. 01:21:11

¿Vale? Poco visual, pero 01:21:13

muy operativo a nivel 01:21:15

de cómo se realiza. ¿Vale? 01:21:17

Hasta aquí, ¿qué tal? 01:21:19

¿Tiene sentido? 01:21:23

Sé que se han 01:21:25

revesado, pero al final es 01:21:27

darles muchas vueltas. Y bueno, hay más 01:21:29

cosas que os pongo en el enunciado. Ahora 01:21:31

voy a decir algunos 01:21:33

atajos o comandos más 01:21:35

importantes, creo. Pero 01:21:37

bueno, en esencia ya veis. Importante 01:21:39

lo de los ifs, ir probando, 01:21:41

porque es verdad que se pueden hacer 01:21:43

muchísimas condiciones concatenadas 01:21:45

y a veces ya cuando se van haciendo 01:21:47

muchas condiciones es complicado saber 01:21:49

qué alude a qué y qué se va haciendo 01:21:51

con qué. ¿Vale? 01:21:53

Entonces, 01:21:55

con esto 01:21:57

ya más o menos podríais ir resolviendo 01:21:59

la tarea. Pero, ¿vale? 01:22:01

Que ya os dije que es una tarea un poco para 01:22:03

que vayáis teniendo. Lo de hacerlo cada 01:22:05

dos segundos se podría hacer, 01:22:07

pero habría que explicar alguna cosa 01:22:09

que de hecho ahora voy a introducir. 01:22:11

Cuando nos quita una vida y no hayamos 01:22:13

muerto, realizaremos un bucle. Habría 01:22:15

que hacer un for 01:22:17

contando las vidas que 01:22:19

quedan. Esto es un poco por practicar 01:22:21

una cosa de un bucle for. Lo veremos más 01:22:23

adelante algún bucle for. Ahora mismo no es 01:22:25

lo que más me preocupa entonces. Lo que sí me 01:22:27

preocupa es explicar cómo se declara un método. 01:22:29

¿Vale? ¿Hasta aquí alguna duda? Que voy a pasar 01:22:31

un poco a otra cosa. 01:22:33

No. Vale. Sigo. 01:22:37

Y bueno, ¿veis que? Incluso 01:22:39

esto que es basiquillo, 01:22:41

¿vale? Y que lo tengo yo planteado, 01:22:43

a veces hay que 01:22:45

darle vueltas y a la primera no sale. No desesperéis. 01:22:47

¿Vale? Esto es sentarse, 01:22:49

ir viendo por qué algo falla, ¿no? Ver 01:22:51

en qué momento está y en qué momento no. 01:22:53

¿Vale? Igual 01:22:55

que aquí vamos teniendo 01:22:57

estos métodos, que pone void start, 01:22:59

void update, nosotros 01:23:01

también podemos ir generando nuestros propios 01:23:03

métodos. ¿Vale? Instantiate. 01:23:05

El otro día os dije, esto es un método. 01:23:07

Debug log es un método, el log. 01:23:09

¿Vale? Y os dije, los métodos se declaran 01:23:11

con un nombre que 01:23:13

empiezan por mayúscula, como start, 01:23:15

y luego tienen un paréntesis. ¿Vale? 01:23:17

Aquí, por ejemplo, log, lo que hay en el paréntesis, 01:23:19

lo que hará será mostrarlo en consola. 01:23:21

Esa es la función de ese método. 01:23:23

Y digo la función de ese método porque se pueden 01:23:25

llamar funciones o métodos. Son iguales. 01:23:27

¿Vale? Pueden tener algo 01:23:29

dentro de estos paréntesis o no. 01:23:31

¿Vale? Si en start tiene algún 01:23:33

parámetro que 01:23:35

tengamos que introducir, 01:23:37

porque está así ideado el método, 01:23:39

lo introduciremos. O puede haber sobrecargas, 01:23:41

como vimos en Instantiate, y que haya distintos tipos 01:23:43

de posibilidades para 01:23:45

usar ese método. Entonces nosotros 01:23:47

podemos también declarar métodos 01:23:49

con varios 01:23:51

propósitos, pero en estos momentos 01:23:53

para poder 01:23:55

reutilizar fragmentos de código. 01:23:57

¿Vale? Por ejemplo, 01:23:59

aquí estamos haciendo algo 01:24:01

que quizás este no es el mejor 01:24:03

ejemplo, aunque se va a entender creo, 01:24:05

pero luego lo iréis viendo 01:24:07

en más ocasiones, en el que yo 01:24:09

no quiero tener en el update 01:24:11

todo el código aquí metido porque 01:24:13

luego el resto de operaciones que hagamos en update, 01:24:15

todo va a ir en este bloque de 01:24:17

update. Y va a ser demasiado código 01:24:19

mezclado, etc. Entonces podemos 01:24:21

ir organizándolo en comportamientos 01:24:23

que conseguimos 01:24:25

en esos métodos. 01:24:27

Los métodos 01:24:29

se declaran al mismo nivel que estos 01:24:31

métodos, habría que matizarlo, 01:24:33

pero de momento como regla, los métodos 01:24:35

se declaran al mismo nivel que 01:24:37

los métodos que hay de ejecución. Es 01:24:39

otro método más. Igual que aquí tenemos un método 01:24:41

void o update, 01:24:43

que no me sale, 01:24:45

a veces me trabo. 01:24:47

En esta misma jerarquía, cuando salgamos de este método, 01:24:49

yo puedo, aquí, 01:24:51

esta es la llave de clase, 01:24:53

de la clase en completa, y aquí podríamos hacer 01:24:55

más métodos. 01:24:57

Por lo general vamos a hacer 01:24:59

métodos que 01:25:01

lo que hacen es recopilar código de otra parte. 01:25:03

Lo que vamos a hacer es, 01:25:05

lo hago primero y luego lo explico, 01:25:07

generar un método que se 01:25:09

llame impacto. Como hemos dicho, 01:25:11

siempre los métodos 01:25:13

con mayúsculas empiezan para 01:25:15

distinguirlos de las variables, por ejemplo, 01:25:17

y se mete paréntesis. 01:25:19

Y luego entre llaves estará todo eso que resume. 01:25:21

Y ahora mismo tenemos de manera 01:25:25

aislada por aquí, igual que las variables 01:25:27

están dentro de la clase pero no se están 01:25:29

ejecutando en ningún momento, 01:25:31

tenemos aquí una variable 01:25:33

llamada impacto. 01:25:35

¿Esto qué es lo que va a hacer? 01:25:37

Que aquí todo lo que metamos dentro 01:25:39

de este código se va a ejecutar siempre 01:25:41

que llamemos a impacto. 01:25:43

Igual que el otro día cuando poníamos 01:25:45

instantiate, cuando instanciábamos 01:25:47

algo, habrá en algún punto del código, 01:25:49

de alguna forma, que haya 01:25:51

un bloque, 01:25:53

llamado instantiate, 01:25:55

que dentro tendrá toda la programación 01:25:57

para que entienda 01:25:59

qué tiene que hacer cuando le pasamos 01:26:01

valores aquí entre estos paréntesis. 01:26:03

Eso está programado ya por defecto 01:26:05

en el lenguaje 01:26:07

que provee Unity. 01:26:09

Entonces, lo que podemos hacer 01:26:11

con un void, 01:26:13

en inglés significa vacío, la nada. 01:26:15

Un void es la nada. 01:26:17

Porque los métodos 01:26:19

también pueden devolver 01:26:21

números, pueden devolver textos, 01:26:23

y hacer operaciones que devuelven 01:26:25

un valor. 01:26:27

A eso si acaso voy un poco más tarde. 01:26:29

Vamos a lo básico. 01:26:31

Si ponemos void, significa que cuando llamemos 01:26:33

a este método, va a pasar por este código, 01:26:35

se va a ejecutar lo del código y listo. 01:26:37

¿Esto qué significa? Que si cogemos 01:26:39

todo lo que hemos hecho antes dentro del update, 01:26:41

cuando digo todo es 01:26:43

todo lo que hay entre estas llaves, 01:26:45

no nos llevamos las llaves porque el bloque tiene que seguir existiendo. 01:26:47

Si yo corto 01:26:49

y lo pego dentro de impacto, 01:26:51

ahora mismo tengo un método llamado 01:26:53

impacto, que 01:26:55

tiene todo este código 01:26:57

esperando a que se llame impacto. 01:26:59

Igual que el otro 01:27:01

hacíamos con 01:27:03

el instantiate, 01:27:07

yo ahora puedo decir impacto, 01:27:09

¿veis que cuando lo he creado 01:27:11

aparece esta clase? 01:27:13

Y ojo, lo he hecho a posta. 01:27:15

Veréis que aparecen dos impactos. 01:27:17

Hay un impacto que empieza con mayúscula 01:27:19

y otro impacto que empieza con minúscula. 01:27:21

Y los dos son nombres además 01:27:23

que he creado yo en algún momento. 01:27:25

Si os fijáis aquí, aparece 01:27:27

esa caja 01:27:29

morada, que significa que es una clase 01:27:31

y esto, 01:27:33

esta caja azul, 01:27:35

estamos mucho con las cajas siempre, 01:27:37

esta caja azul que es una variable. 01:27:39

Yo he creado la 01:27:41

función impacto con i mayúscula 01:27:43

y aquí al principio 01:27:45

tenemos la variable impacto 01:27:47

con i minúscula, y por eso lo sé 01:27:49

distinguir, por eso es importante, porque veis 01:27:51

que cuando estamos haciendo un juego 01:27:53

con lógicas es muy fácil 01:27:55

que se llamen igual las variables, 01:27:57

los métodos, lo que hacemos, disparo. 01:27:59

Por disparo puede ser 01:28:01

el daño que hace ese disparo 01:28:03

o la acción de disparar. 01:28:05

La forma de distinguirlo es 01:28:07

un poco con el método de escritura. 01:28:09

Yo ahora cuando llame 01:28:11

a impacto 01:28:13

lo que estoy haciendo es 01:28:15

que en el update está todo el rato buscando 01:28:17

dentro de impacto, y aquí 01:28:19

tengo solo en este momento 01:28:21

una línea que llama a este 01:28:23

método y ejecuta lo que hay en el método. 01:28:25

Es verdad que no va a pasar nada porque hasta que no puse 01:28:27

una de las teclas que están aquí configuradas 01:28:29

pues no va a pasar nada. 01:28:31

Pero si 01:28:33

este impacto lo quiero usar 01:28:35

aquí también, 01:28:37

lo quiero tanto 01:28:39

en el start como en el 01:28:41

update. 01:28:43

Yo simplemente 01:28:45

con poner la palabra impacto 01:28:47

o cuando yo pulse la tecla 01:28:49

no sé cuánto, 01:28:51

se puede llamar a impacto 01:28:53

para que se reproduzca 01:28:55

lo que hay aquí. 01:28:57

Una forma de resumir 01:28:59

partes de código 01:29:01

se puede hacer de forma 01:29:03

como la que tenemos aquí que es 01:29:05

creando un método de tipo vacío 01:29:07

y con el nombre que queramos. 01:29:09

Ahora básicamente 01:29:11

lo que va a estar haciendo en el update 01:29:13

todo el rato es, y esto no es muy eficiente 01:29:15

ahora mismo porque estamos 01:29:17

a diferencia de antes, está todo el rato 01:29:19

mirando lo que hay dentro 01:29:21

y dice hasta que no le dé a la tecla espacio 01:29:23

pues no se mete. 01:29:25

Que impacto a lo mejor podría ejecutarse 01:29:27

en el momento en el que 01:29:29

pusiéramos un if y se ejecute. 01:29:31

Pero es verdad que como hemos metido dos 01:29:33

ifs de tipo 01:29:35

pulse a tal tecla, pues lo suyo 01:29:37

es que vaya comprobando 01:29:39

este impacto porque 01:29:41

vaya buscando 01:29:43

qué input estamos tocando en todo momento. 01:29:45

Pero si lo pensamos bien 01:29:47

realmente 01:29:51

este impacto 01:29:53

solo se debería referir a cuando le damos 01:29:55

a la barra espaciadora, que es cuando generamos el impacto. 01:29:57

Esta de pulsar la R 01:29:59

realmente no es 01:30:01

la acción de impacto, 01:30:03

es la acción de reiniciar 01:30:05

juego o reiniciar 01:30:07

o reinicio o reseteo, lo que queramos. 01:30:09

Entonces estamos mezclando en un mismo método 01:30:11

dos tipos de acciones. 01:30:13

Nos puede interesar o no, 01:30:15

pero realmente no tiene lógica. 01:30:17

Lo que deberíamos hacer es que en el update 01:30:19

se ejecute el impacto cuando pulsemos una tecla. 01:30:21

Por tanto, la condición 01:30:23

que igual deberíamos hacer es 01:30:25

si se cumple esto mismo que estábamos haciendo 01:30:27

que tenemos aquí 01:30:29

pues que llame 01:30:31

a impacto y mire lo que hay dentro. 01:30:33

Entonces ahora en el update 01:30:35

hasta que yo no pulse esto 01:30:37

no se ejecuta esto. 01:30:39

Es verdad que ahora habrá que 01:30:41

reconfigurar, refactorizar 01:30:43

se puede llamar también que es recalibrar 01:30:45

un poco todo lo que hemos estado 01:30:47

trabajando para que 01:30:49

según le demos a la barra espaciadora 01:30:51

ya se ejecute este impacto. 01:30:53

Todas las acciones de impacto 01:30:55

hasta aquí. 01:30:57

Que es 01:30:59

donde termina de ejecutarse 01:31:01

la acción que estamos haciendo. 01:31:03

Es decir, ahora mismo si pulsamos 01:31:05

a la tecla espaciadora y estoy vivo 01:31:07

que por defecto lo estoy 01:31:09

se ejecuta todo lo que hay en impacto. 01:31:11

Se asigna un número aleatorio 01:31:13

de impacto, si vale más que el escudo 01:31:15

si tienes vidas tal o cual 01:31:17

te mata o no. 01:31:19

Pero lo que vamos a hacer es 01:31:21

en otro momento 01:31:23

diferente, si pulsamos 01:31:25

la tecla R y se dan las 01:31:27

características pues pasa 01:31:29

a ocurrir esto. Y esto sería otro 01:31:31

método. Esto sería el método 01:31:33

un segundito 01:31:37

y hay que ver bien en que nivel estamos 01:31:39

saliendo de este nivel 01:31:41

está mal tabulado y aquí 01:31:43

sobra una llave. Cuando salen a veces 01:31:45

llaves así sueltas es que cuando 01:31:47

hemos ido trabajando 01:31:49

hemos dejado alguna llave sin borrar. 01:31:51

Entonces ahora tenemos 01:31:53

todo el método que resume lo de impacto 01:31:55

y podemos hacer otro bolt que sea 01:31:57

resetear 01:31:59

y 01:32:01

reseteamos y entonces 01:32:03

lo que vamos a hacer es si pulsamos 01:32:05

tenemos aquí preparado este código 01:32:07

si pulsamos esta tecla 01:32:09

que se ejecute esto 01:32:11

pero a lo mejor voy a resetear 01:32:13

en distintos momentos del juego al pulsar la 01:32:15

R 01:32:17

con distintos atajos 01:32:19

entonces resetear 01:32:21

puede ser que siempre 01:32:23

haga que ponga reiniciado el juego y se 01:32:25

vuelvan a resetear otra vez 01:32:27

todas las variables 01:32:29

que yo lo puedo hacer con 01:32:31

la tecla R vivo y digo 01:32:33

resetear 01:32:35

entonces yo cuando pulse 01:32:37

esa tecla y se cumple 01:32:39

la condición de que es falso 01:32:41

pues al pulsar la R se reinicia 01:32:43

es un poco lo mismo pero es verdad que ahora 01:32:45

en cualquier momento del código o incluso en otros 01:32:47

scripts que tengamos que vayamos conectando 01:32:49

que tengamos por ahí 01:32:53

con poner resetear solo 01:32:55

ya estamos 01:32:57

hablando de todo esto y no hay que copiar 01:32:59

otra vez todo el código 01:33:01

no sé si me vais entendiendo 01:33:03

ahora mismo el juego 01:33:05

es prácticamente lo mismo 01:33:07

pero 01:33:09

lo hemos escrito 01:33:11

de una manera ligeramente diferente 01:33:13

y más reutilizable 01:33:15

cuando 01:33:17

usabais Instantiate 01:33:19

básicamente lo que se estaba haciendo era 01:33:21

un método o varios métodos 01:33:23

llamados Instantiate 01:33:25

que hacen ciertas operaciones 01:33:27

ahora yo vuelvo al juego 01:33:29

vuelvo al editor 01:33:31

y cuando 01:33:33

yo le doy aquí al 01:33:35

juego 01:33:37

la nave tiene 76 de escudo 01:33:39

según se arranca 01:33:41

la nave tiene 01:33:43

78 de escudo 01:33:45

fijaos 01:33:47

creo que antes he puesto algo por aquí 01:33:49

y ahora inicio el juego y ya me pone lo de la nave 01:33:51

tiene 78 de escudo y luego el escudo de la nave 01:33:53

tiene una energía de 78 01:33:55

mientras os iba explicando puse aquí impacto 01:33:57

y aquí no he puesto ninguna condición 01:33:59

aquí según arranca el juego se ponen las variables 01:34:01

se ejecuta el impacto 01:34:03

se lee todo lo que hay aquí 01:34:05

y luego ya me lee 01:34:07

el escudo tiene tantas cosas 01:34:09

tiene tanto de escudo y tanto tal 01:34:11

fijaos que aquí he llamado a un impacto 01:34:13

y por tanto ha hecho 01:34:15

el primer lanzamiento 01:34:17

del meteorito se ha hecho 01:34:19

sin pulsar ninguna tecla porque aquí no hay ninguna condición 01:34:21

a diferencia de aquí 01:34:23

entonces este impacto básicamente habría que borrarlo 01:34:25

porque no me interesa tenerlo ahí 01:34:27

pero veis que con una sola frase ya ha hecho un montón de acciones 01:34:29

que antes ha costado un montón 01:34:31

hacer aquí, vamos que tiene muchas líneas 01:34:33

y si quisiéramos 01:34:35

imaginaos que si quisiéramos que fuera así 01:34:37

no íbamos a escribir el código este tan largo 01:34:39

en el start y luego en el update 01:34:41

pues veis que se puede resumir y con una sola 01:34:43

llamadita 01:34:45

pues lo tenemos ahí para irlo 01:34:47

para irlo 01:34:49

para ir apelando a él 01:34:51

entonces ahora sí que sí 01:34:53

después de este 01:34:55

pequeño error del directo que dejé ahí 01:34:57

esta 01:34:59

esta llamada al 01:35:01

método impacto 01:35:03

pues si ahora inicio el juego 01:35:05

vale, inicio 01:35:07

empieza el escudo de la nave, tiene 01:35:09

100 de energía, pues ya empieza a jugar 01:35:11

le doy a la barra espaciadora 01:35:13

vale, empieza a jugar, empieza a jugar 01:35:15

y es exactamente el mismo juego 01:35:17

cuando llego a 0 vidas y estoy muerto 01:35:19

le tengo que dar 01:35:21

a la R 01:35:23

a reiniciar el juego, he llamado 01:35:25

a resetear porque se 01:35:27

daban las condiciones de que estuviera muerto 01:35:29

o no vivo 01:35:31

y le doy a la R 01:35:33

y otra vez volvemos a jugar 01:35:35

el update está continuamente viendo a ver si hacemos 01:35:37

en este caso una de estas dos acciones 01:35:39

que se cumplan, y ahí estamos 01:35:41

puedo volver a jugar y otra vez 01:35:43

hasta que lo mate 01:35:45

y ya se ha acabado el juego, R y vuelvo a 01:35:47

vale 01:35:49

entonces, lo que quiero que nos 01:35:51

llevemos hoy es que nosotros 01:35:53

podemos crear nuestras propias acciones 01:35:55

en esto que se llaman métodos 01:35:57

y de momento hemos visto un método 01:35:59

que es el void, pero luego puede haber 01:36:01

métodos que por ejemplo devuelvan un int 01:36:03

esto ya es más complejo 01:36:05

da un error ahora mismo porque hay que 01:36:07

poner otro comando y tal, pero bueno 01:36:09

me sirve con que sepáis que 01:36:11

como se declara un método 01:36:13

que está fuera de estos métodos 01:36:15

es como otro método distinto al 01:36:17

startUpdate y por eso 01:36:19

debería estar al mismo nivel 01:36:21

y 01:36:23

se puede llamar en cualquier momento de esta forma 01:36:25

poniendo su nombre y los paréntesis 01:36:27

¿qué tal? 01:36:29

¿hasta aquí qué tal vais? 01:36:31

¿se entiende 01:36:35

todo esto? 01:36:37

vale 01:36:41

más cosas 01:36:43

nos quedan como 10 minutillos 01:36:45

quiero apurar y explicar ciertas cosas 01:36:47

que son las típicas 01:36:49

cosas pequeñas 01:36:51

sí, por supuesto 01:36:53

tenéis el enunciado de la tarea 0 01:36:55

a lo mejor lo podéis intentar replicar vosotros 01:36:57

y se puede hacer esto 01:36:59

de 250 formas 01:37:01

porque al final la lógica puede ser al revés 01:37:03

si empieza diciendo si escudo es menor 01:37:05

que impacto y ya te cambia el orden de las condiciones 01:37:07

pero sí, sí 01:37:09

es practicarlo 01:37:11

por eso esta tarea es tan útil 01:37:13

en el sentido de ir poniendo 01:37:15

y todavía no hemos hecho lo del bucle 01:37:17

ni lo de los 2 segundos 01:37:19

que para eso habría que usar lo que se llaman corrutinas 01:37:21

que ya están explicadas en el tema 2 01:37:23

si no me equivoco, ya está abierto 01:37:25

ya son cosas complejillas 01:37:27

pero bueno, ya vais poco a poco viendo 01:37:29

cómo se van haciendo algunas cosas 01:37:31

importante 01:37:33

aquí ponía una condición, lo digo por si alguna vez 01:37:35

algo que os sugiero moderadamente 01:37:37

pero bueno, a veces puede venir bien 01:37:39

que no sepáis tirar para adelante 01:37:41

y se lo preguntéis a una inteligencia artificial 01:37:43

¿cómo harías para hacer esto? 01:37:45

y os puede dar código 01:37:47

esto sí que lo recomiendo 01:37:49

o que estéis viendo la documentación con ejemplos 01:37:51

en algunos momentos puede aparecer 01:37:53

un booleano que en vez de poner vivo 01:37:55

igual a true, si está vivo 01:37:57

si simplemente pone vivo 01:37:59

como lo que está buscando es que se cumplan 01:38:01

estas condiciones, esto significa que vivo 01:38:03

sea true, si no, no se cumple la condición 01:38:05

cuando es falso 01:38:07

sí que hay que especificarlo 01:38:09

pero si solo pone la palabra de una variable 01:38:11

y es booleana, significa que si eso es true 01:38:13

pues adelante, se ejecuta 01:38:15

es exactamente lo mismo poner esto 01:38:17

que poner esto 01:38:19

y antes os he dicho 01:38:21

que está el operador 01:38:23

para invertir la condición 01:38:25

en vez de decir es igual a 01:38:27

es contrario, es diferente, lo opuesto a 01:38:29

con esta exclamación 01:38:31

hay otra forma 01:38:33

de decir que esto es 01:38:35

hay otra forma de decir que esto es 01:38:39

igual a falso 01:38:41

aquí he dicho que si lo dejo así escrito 01:38:43

es exactamente lo mismo 01:38:45

y para decir que algo es igual a falso 01:38:47

lo digo porque los booleanos se usan tanto 01:38:49

que es conveniente hacernos a la idea 01:38:51

de que existe esto 01:38:53

en vez de decir es igual a falso 01:38:55

si alguna vez encontráis 01:38:57

que una variable booleana tiene esta exclamación 01:38:59

por delante, significa que es lo contrario 01:39:01

a que se esté dando esto 01:39:03

no está vivo, vivo no es falso 01:39:07

es lo opuesto 01:39:09

esto significa que esta variable 01:39:11

si esta variable es falsa 01:39:13

pues se ejecuta 01:39:15

sería exactamente igual 01:39:17

es decir 01:39:19

vivo igual a falso 01:39:23

es similar a 01:39:27

vivo 01:39:31

y aquí lo mismo, si no se pone nada 01:39:35

es igual 01:39:37

más cosas 01:39:39

cuando en el momento que morimos 01:39:41

decimos que vivo pasa a ser falso 01:39:43

hay otra operación que en ocasiones 01:39:45

es fundamental 01:39:47

que es invertir el booleano 01:39:49

aquí impepinablemente estamos diciendo 01:39:51

que vivo ya venga siendo 01:39:53

verdadero o falso 01:39:55

que en este momento pasa a ser falso 01:39:57

tenemos una acción que es 01:39:59

dar a un interruptor 01:40:01

cuando das a un interruptor 01:40:03

imaginaos un Resident Evil 01:40:05

que os acercáis a una puerta 01:40:07

y podéis encender y apagar la luz 01:40:09

y usáis el método 01:40:11

conmutador luz 01:40:13

hacéis un método 01:40:15

que guarde dentro conmutador luz 01:40:17

y que se encienda o apague la luz 01:40:19

va en base 01:40:21

a que haya una booleana 01:40:23

que sea verdadera o falsa 01:40:25

podemos reciclar el mismo 01:40:27

el mismo 01:40:29

método 01:40:31

si lo que hacemos en vez de decir que sea vivo 01:40:33

pasa a ser falso impepinablemente 01:40:35

si delante de la asignación 01:40:37

de lo siguiente ponemos la exclamación 01:40:39

me explico 01:40:41

si yo cojo vivo 01:40:43

y le digo que pasa a valer esto 01:40:45

significará que si vivo venía siendo verdadero 01:40:47

pasa a ser falso 01:40:49

y si venía siendo falso 01:40:51

pase a ser cierto 01:40:53

aquí siempre nos interesa 01:40:55

porque igual en algún momento lo habíamos dejado falso 01:40:57

y de pronto revivimos en el momento 01:40:59

que llega a ser cero 01:41:01

lo cual no tendría ningún sentido dentro de la lógica 01:41:03

de que cuando llegamos a cero pase tal cosa 01:41:05

entonces aquí siempre nos interesa que si se da esta condición 01:41:07

de las vidas a cero 01:41:09

pues pasa a ser cero 01:41:11

pero en un conmutador a lo mejor tenemos la acción 01:41:13

intercambiar luz 01:41:15

pues con esto vamos 01:41:17

pasando de una booleana 01:41:19

a otra 01:41:21

la condición es que si encendido es verdadero 01:41:23

se ejecuten 01:41:25

o si no es verdadero 01:41:27

pasa a ser falso 01:41:29

pues no se ejecuten 01:41:31

un poco lo mismo que hemos hecho aquí 01:41:33

con esta lógica 01:41:35

que no es solo pulsar la tecla asignada 01:41:37

sino que aparte se da otra condición 01:41:39

de que un semaforito 01:41:41

está activo o no 01:41:43

a veces no sé si os ayudo con lo de semaforitos 01:41:45

y cajas pero yo creo que 01:41:47

viendo esos símbolos es más sencillo 01:41:49

de todo 01:41:51

y paso a 01:41:53

para ir cerrando un poco 01:41:55

si yo cojo 01:41:57

voy a coger 01:41:59

una variable 01:42:01

mira vamos a hacerlo 01:42:03

de otra forma 01:42:05

si yo aquí durante el update 01:42:07

creo otro método 01:42:09

que se llame conmutar 01:42:11

esto no tiene nada que ver 01:42:13

con el juego de la nave pero bueno 01:42:15

yo estoy llamando a un método 01:42:17

que se llama 01:42:19

tabulo 01:42:21

que se llama conmutar y da fallo 01:42:23

por una razón muy simple que es que 01:42:25

no he creado ningún método 01:42:27

llamado conmutar, si yo bajo y digo 01:42:29

al mismo nivel que el resto de métodos 01:42:31

voy a hacer un void 01:42:33

porque va a recopilar código y ya está 01:42:35

va a pasar por ese código, va a hacer como un resumen de comedio 01:42:37

lo llamo conmutar 01:42:39

lo creo aquí con las llaves para meter 01:42:41

veis que ya no hay ningún fallo 01:42:43

entonces ahora en el update se está conmutando 01:42:45

está todo el rato mirando 01:42:47

a ver que hay aquí dentro 01:42:49

y si yo ahora mismo digo 01:42:51

en conmutar quiero que 01:42:53

vamos a poner una variable nueva 01:42:55

para este ejemplo, la creo como global 01:42:57

que sea boolean 01:42:59

encendido 01:43:01

pues vale 01:43:03

tengo este boolean encendido y cuando arranca el juego 01:43:05

imaginaos que es que la nave 01:43:07

espacial hay que arrancarla 01:43:09

y cuando empieza el juego 01:43:11

directamente 01:43:13

por defecto ya aparece 01:43:15

encendida, por tanto es true 01:43:17

true 01:43:19

lo lógico es poner palabras 01:43:21

o frases que digan, ¿esto se está cumpliendo? 01:43:23

sí, pues encendido, pues true 01:43:25

pues encendido, true 01:43:27

ojo que si no declaráis nada, no inicializáis 01:43:29

en ningún momento, ya os dije que por defecto 01:43:31

las booleanas valían falso 01:43:33

por defecto, por tanto por defecto 01:43:35

si yo no pusiera nada aquí y luego llamo a encendido 01:43:37

eso valdría falso 01:43:39

pero aquí lo estamos inicializando en encendido 01:43:41

entonces 01:43:43

lo que voy a hacer es 01:43:45

que cada fotograma, cuando yo 01:43:47

pulse 01:43:49

si pulso la tecla 01:43:51

a ver, copio un poco, bueno lo escribo para 01:43:53

que quede más claro 01:43:55

yo siempre cuando escribo un condicional empiezo 01:43:57

escribiendo esto y luego ya voy 01:43:59

rellenando, digo las llaves, pues aquí voy 01:44:01

a meter lo que quiero que se realice 01:44:03

ya lo tengo ahí, el comutar esperando 01:44:05

y aquí la condición es 01:44:07

si yo 01:44:09

hago un input D, que pulso una vez 01:44:11

una tecla, get key down 01:44:13

y esa tecla, pues voy a 01:44:15

decir que sea la tecla 01:44:17

pues yo que sé, aquí con 01:44:21

keycode vamos a ir, pues por ejemplo 01:44:23

la tecla 01:44:25

la J 01:44:27

no sé por qué, o la C de 01:44:29

comutar, le doy aquí 01:44:31

y ahí está, cada vez que le de a la C 01:44:33

no hay otra condición que impida que se ejecute o no 01:44:35

se va a producir lo que 01:44:37

viene en comutar 01:44:39

y aparte, bueno, sí 01:44:41

aquí se va a producir lo de comutar y entonces 01:44:43

yo aquí lo que voy a decir es 01:44:45

encendido 01:44:47

venga valiendo lo que venga 01:44:49

pues voy a decir que pasa a ser 01:44:51

lo contrario, la booleana, entonces 01:44:53

cada vez que le de, igual que pasa con el interruptor 01:44:55

o lo enciendes o lo apagas cada vez que le pulsas 01:44:57

y para ir comprobando cuánto vale 01:44:59

en cada momento, según cambio la 01:45:01

asignación de qué vale, pues voy a decir 01:45:03

un debug log 01:45:05

debug 01:45:09

no quiere ayudarme, ahí 01:45:11

debug log que me enseñe lo que vale 01:45:13

encendido, vale, entonces 01:45:15

cada vez que yo le de a esa tecla C 01:45:17

encendido pasará a ser lo opuesto 01:45:19

y lo veremos en encendido, vale, y lo veremos 01:45:21

como true o false, recordad que esto 01:45:23

vuelvo a ir al comienzo 01:45:25

es una booleana, solo alberga esta caja 01:45:27

verdaderos o falsos, vale, entonces 01:45:29

guardo, voy al juego 01:45:31

bueno, me va a poner 01:45:33

todo el inicio de 01:45:35

el escudo de la nave tiene 100 01:45:37

ahora mismo no nos da igual, y cuando yo le 01:45:39

de a C, según le de a C 01:45:41

vuelvo a dar aquí 01:45:43

dice falso, empieza como 01:45:45

verdadero y la primera vez que le he dado es falso 01:45:47

vuelvo a dar a C, verdadero, falso 01:45:49

verdadero, falso, vale 01:45:51

esto es muy útil para muchas 01:45:53

acciones, para ir intercambiando lo que 01:45:55

haces, pues activo o desactivo 01:45:57

el arma, pues habrá una tecla que lo que hace 01:45:59

es, con una operación parecida 01:46:01

a esta, invertir 01:46:03

el modo en el que venía 01:46:05

vale, ¿se entiende? 01:46:07

si quisiéramos ser más 01:46:09

correctos 01:46:11

pues si queremos informar al 01:46:13

al 01:46:15

usuario, pues aquí habría que decir 01:46:17

como empieza 01:46:19

el conmutador 01:46:21

está 01:46:23

aquí te digo 01:46:25

encendido, y dirá true o false 01:46:27

vale, y aquí en cada 01:46:29

operación, pues en vez de poner 01:46:31

apelo 01:46:33

encendido o falso, pues 01:46:35

ponemos el conmutador 01:46:37

pasa 01:46:39

a estar, vale 01:46:41

concatenamos, e igual que 01:46:43

con los números, pues ahí pondrá 01:46:45

true o false 01:46:47

como un texto, entonces 01:46:49

empieza el juego, y empieza y te dice, oye 01:46:51

el conmutador está true, vale 01:46:53

pues le doy a la C, oye el conmutador 01:46:55

pasa a estar false, true, cada vez que le estoy 01:46:57

dando, vale, se va invirtiendo 01:46:59

¿sí? 01:47:01

bueno, pues por hoy creo que está bien 01:47:05

ya podéis 01:47:07

también 01:47:09

incluso intentar 01:47:11

mientras vais leyendo el tema 2 01:47:13

intentar ir probando más tipos 01:47:15

de inputs, vale, aquí he usado lo del teclado 01:47:17

pero se van explicando más en el tema 01:47:19

pues en vez de, si tenéis 01:47:21

el ratón, pues cuando vais pulsando 01:47:23

al botón 01:47:25

izquierdo, pues que ocurra lo que ocurra 01:47:27

y vais probando más inputs, podéis 01:47:29

ya ir probando más formas de interactuar 01:47:31

podéis hacer el bucle 01:47:33

for, que sí que lo explica 01:47:35

se explica en el tema 0 01:47:37

sino ya un día lo veremos, vale 01:47:39

podéis ir creando ya métodos 01:47:41

esto lo hemos aprendido hoy 01:47:43

podéis dar otros números aleatorios 01:47:45

también, vale, se pueden hacer 01:47:47

bastantes cosillas ya, hay videojuegos 01:47:49

así de simples que funcionan 01:47:51

así que mira, ya podríamos decir 01:47:53

hasta que hemos hecho el 01:47:55

el primer videojuego 01:47:57

bueno chicos, si hay alguna 01:47:59

duda de los contenidos, de la tarea de 01:48:01

del tema 2, que os sugiero 01:48:03

mucho ya que os vayáis intentando 01:48:05

pegar con ella 01:48:07

ven los videos de Álvaro, que son 01:48:09

lo que explica Álvaro en los videos 01:48:11

entra como materia de examen 01:48:13

también, vale, es tan material 01:48:15

como lo escrito 01:48:17

Tutoría 3 - DEIM - UT2 y 0 - Curso 23·24 - 14 Diciembre - Contenido educativo

Del mismo autor…

Mantenimiento_del_Motor (aceite y filtros)

Cochlear: Sincronizar mando con IC

Obra de teatro 5º

Baile de Navidad. Alumnos de comedor Escolar.

Concurso Belén Chamartín-2025

DT1.GP.U4.1.2b y 4.1.3a_ Ovoides y Espirales

Vídeo presentación APEb 2025 2026