Tutoría 8 - DEIM - UT4 - Curso 23·24 - 7 Marzo

Vale, mira, tengo las siguientes dudas. En primer lugar, el tema es el... 00:00:02

Bien, he conseguido hacer sobre el juego anterior, sobre el de las plataformas de la bola, 00:00:06

he hecho una pantalla de inicio, sobre la pantalla de inicio he puesto varias opciones, 00:00:12

que es la... bueno, le he metido la música, he puesto varias opciones, 00:00:16

cuando pinchas en opciones, a través de la consola, pues... 00:00:20

Ah, bueno, he puesto un kit, para que me mande un kit desde la siguiente pantalla 00:00:25

Y me lo muestra en la pantalla de la consola 00:00:30

En la consola solamente 00:00:33

En vez del proyecto en consola 00:00:34

En donde está 00:00:37

Entonces yo entiendo que ahí se tiene que quedar 00:00:38

Esa parte se queda ahí 00:00:41

Luego, el tema de los corazones 00:00:42

El quitar las vidas es lo que peor 00:00:45

Vamos, que no consigo hacerlo 00:00:47

He metido el screen, me he estado viendo varias veces los tutoriales 00:00:48

Que vienen ahí en la aplicación 00:00:51

Y ya está, sí que es verdad que meto los sprites 00:00:53

Lo divido, lo corto 00:00:55

Los corazones en tres partes 00:00:57

Luego vinculo, hago los scripts necesarios para vincularlo 00:00:58

Pero no consigo que se me quiten los corazones 00:01:03

Cada vez que la bola, por ejemplo, cae a través de un trigger 00:01:06

Que cae en la parte de abajo, pues no consigo hacer que se quite 00:01:09

Y luego tenía una duda porque quería hacer un slider 00:01:12

Relacionado con la música, para subir y bajar el volumen 00:01:17

Entonces no sé si es, hay que hacerlo en la pantalla de inicio 00:01:21

o que se pueda bajar, subir y bajar en todas las pantallas 00:01:26

vale, bueno, en primer lugar 00:01:29

en ningún caso se hablaba de meter música 00:01:30

porque la música se da en un tema posterior 00:01:32

entonces, claro 00:01:34

el slider se debía usar para el nivel 00:01:36

de dificultad del juego 00:01:38

vale, entonces 00:01:39

lo del slider, si te parece 00:01:42

te lo explico, relacionado con lo que 00:01:44

se debería hacer en la práctica 00:01:46

y posteriormente realmente es 00:01:47

convertirlo a que el volumen 00:01:50

del audio se regule con eso 00:01:52

pero bueno, vale 00:01:54

Bueno, te hago una pregunta un poco obvia 00:01:56

No me puedes compartir el proyecto para que lo veamos 00:01:58

Junto, ¿verdad? 00:02:01

¿Sabes lo que pasa? Bueno, dentro de un rato sí 00:02:03

Porque voy a coger el tren para el aeropuerto 00:02:04

Y cuando esté en el aeropuerto ahí me voy a conectar con el portal 00:02:06

Que me lo he traído, para poder conectarlo precisamente 00:02:08

Pero que me pillase 00:02:11

A lo mejor en 20 minutos 00:02:12

Media hora sí 00:02:15

Aún así te puedo ir hablando 00:02:15

Digo, que vas a estar escuchándome 00:02:18

Sí, sí, estoy pendiente, estoy con el móvil pendiente 00:02:20

Vale, sí, lo digo porque voy a ir como preguntándote 00:02:22

cosas de vez en cuando, porque claro, yo sin verlo 00:02:24

me imagino lo que me está contando, 00:02:26

pero es complicado, vaya. 00:02:28

Entonces, claro, 00:02:30

volví. Yo me voy a ceñir un poco 00:02:33

a lo que es el enunciado del tema. Por ejemplo, 00:02:34

lo del volumen, en el último tema, 00:02:36

se va a ver clarísimamente, y si entendéis cómo hacer ese 00:02:38

slider con los niveles, 00:02:40

de hecho, para la música es más sencillo, 00:02:42

porque está comunicado. 00:02:44

Si no, más adelante ya lo veremos. 00:02:46

Sí, entiendo que más o menos lo que está 00:02:50

recreando es una ventana como esta, 00:02:52

En la que si das 00:02:54

Bueno, lo vimos en la última tutoría 00:02:55

De hecho, que si le das a jugar lanzaría el juego 00:02:57

No le doy, paso a la siguiente 00:02:59

En config tenemos este slider 00:03:01

Para el nivel de dificultad que ves que hay cuatro 00:03:03

Perdona, no puedo ver tu pantalla 00:03:05

No puedo ver ahora 00:03:08

Perdona, perdona, claro, es que la estaba compartiendo 00:03:08

Pero 00:03:11

Sí, ahora sí 00:03:11

Sí, sí, sí 00:03:21

Arranco el juego, ¿vale? 00:03:22

Y entonces la primera pantalla 00:03:26

Era esta que en principio 00:03:27

se pedía que se configuraran tres posibilidades, tres posibles botones. 00:03:29

Uno es el de jugar, que no le doy, para lanzar el juego. 00:03:33

Voy a jugar un poco para que se vean estas tres vidas. 00:03:39

Y fíjate que yo en el material, por lo que te he entendido, 00:03:43

en el material que proporcionaba para la práctica, había cuatro... 00:03:46

Bueno, no, de hecho había tres imágenes diferentes 00:03:51

que corresponden con las que estamos viendo aquí, 00:03:53

es decir, con las que ya están como sombreadas, las vidas que se han muerto. 00:03:56

No hay que trocearlas, en realidad sustituir, según el momento en el que nos encontremos, cada una de las imágenes, ¿vale? Ahora lo vemos, pero no había que trocear nada. Sí que es verdad que en el vídeo, si no me equivoco y estás haciendo referencia al de Álvaro, se juega con él con un solo corazón que se repite y se va, digamos, cambiando la anchura de los corazones porque se va tileando, ¿no? Se va como repitiendo. 00:03:59

Eso es, se mete 00:04:22

lo corta, lo convierte 00:04:24

primero en un sprite 00:04:26

que te diga cómo se tiene que hacer, luego lo corta 00:04:28

y luego ya a partir de ahí te lo va colocando en la pantalla 00:04:30

Claro, la cosa es que yo 00:04:32

en esta tarea, si te fijas, el enfoque 00:04:34

es un poco diferente 00:04:36

y más sencillo, ¿no? 00:04:38

Porque, bueno, voy por partes 00:04:40

¿vale? Para hacer ese HUD 00:04:42

ese, nunca sé si se dice 00:04:44

HUD, que se 00:04:46

pone como un overlay 00:04:48

¿vale? Como un overlay encima del juego 00:04:49

en los niveles que queramos que estén 00:04:52

lo primero que se sugiere en el enunciado es 00:04:53

que yo he generado un prefab 00:04:56

que luego podré ir arrastrando a cada nivel 00:04:57

con ya todos los elementos 00:04:59

dado que todos los niveles jugables van a tener 00:05:01

las mismas datos 00:05:03

de prefab, pues ya aprovecho 00:05:06

y que ya esté preconfigurado 00:05:07

incluso con algún script ya 00:05:09

los diferentes elementos 00:05:11

lo que iremos jugando a través del código 00:05:14

es que ponen 00:05:16

el nombre del jugador 00:05:17

cuantos 00:05:19

Bueno, pues cuántos corazones 00:05:20

Mejor dicho aquí 00:05:23

Cuántas vidas nos quedan, ¿vale? 00:05:24

En este caso, básicamente eso 00:05:27

Entonces, por ejemplo, en el tema de las vidas 00:05:29

Voy a ese caso concreto 00:05:32

Está 00:05:34

La propia imagen que se está cargando 00:05:35

Que aquí tenemos la de Livestress 00:05:38

Pero lo que te comentaba, en el material que os pasaba 00:05:39

A ver 00:05:42

De hecho 00:05:43

Sí, vienen diferentes 00:05:44

Es decir, que no 00:05:47

No, digo porque he entendido que tú lo que has empezado a hacer, que se podría también de otros modos, pero en este caso sería menos operativo y de hecho no es el modo que yo más sugeriría para algo así con tan pocas vidas, ¿vale? 00:05:49

No hay que trocear nada, ¿vale? Porque lo que habría que hacer es que la imagen que se está viendo aquí en el HUD, en este componente imagen, que empieza por defecto como el de las tres vidas, según vayan sucediendo cosas, pues se cargue la imagen de dos vidas, la de una vida, ¿vale? 00:06:01

Sin una duda. 00:06:18

Sí. 00:06:19

Es que lo he intentado, claro, en el script he metido un array, ¿no? 00:06:19

Y en el array he metido cada uno de estos tres, de estos cuatro. 00:06:22

Vale. 00:06:25

Metiendo de cero a cero, uno, dos y tres. 00:06:25

Entonces, lo he intentado, pero es que no me sale. 00:06:28

Vale. 00:06:30

Sí, sí, ¿no? 00:06:31

Bueno, que no pasa nada, para eso de la tutoría. 00:06:32

Vale, algo importante es que siempre, esto no es una regla 100%, 00:06:35

pero normalmente cuando creemos un canvas con diferentes cosas dentro, 00:06:40

si queremos manipular la información que hay dentro, ¿vale? 00:06:44

Los aspectos de los distintos inputs, imágenes, etcétera, se debería unificar normalmente en un... 00:06:47

Aquí es en el HUD, pero, por ejemplo, si voy al menú de configuraciones que tenía tres botones, 00:06:54

ese canvas también tiene, digamos, la configuración de las acciones de los botones ahí. 00:06:58

Ahora, de hecho, iremos. 00:07:03

Me voy a centrar en esta duda concreta. 00:07:05

Si te fijas, aquí lo que hay en este canvas es, por un lado, una referencia, ¿vale? 00:07:06

Y me voy a meter ya en el script también para tenerlo aquí abierto. 00:07:13

¿vale? Estás en el canvas 00:07:17

del menú de inicio, ¿no? Por lo que veo. 00:07:18

No, en el canvas del HUD 00:07:20

mientras se juega, que es un 00:07:22

prefab que yo ir arrastrando, 00:07:24

¿vale? Estoy yendo, 00:07:26

digamos, primero a por lo del HUD 00:07:28

porque es como una duda más concreta 00:07:30

que otras que me has hecho. Entonces, 00:07:32

para atajar esta. Yo cuando voy abriendo 00:07:34

los distintos niveles, 00:07:36

lo que he hecho, ¿vale? Es 00:07:39

arrastrar un prefab que es 00:07:40

ese HUD. Esto, ¿vale? Lo voy a volver a 00:07:42

arrastrar. En cada nivel puedo 00:07:44

ir arrastrando ya un prefab que he hecho 00:07:46

es decir, ese prefab es el que 00:07:48

me va a aportar lo que es 00:07:50

este canvas que se va a sobreponer 00:07:53

sobre los niveles de juego 00:07:54

no en el menú inicial 00:07:56

y en el de configuración no, porque ahí no 00:07:59

tenemos necesidad de 00:08:00

feedback de las vidas que nos quedan 00:08:03

al menos tal y como está planteado este juego 00:08:04

pero luego en cada nivel jugable sí 00:08:06

vale, entonces entiendo que 00:08:08

lo que has hecho es un canvas 00:08:10

sobre por ejemplo el de la escena número 1 00:08:13

has hecho un prefab y ese lo has arrastrado 00:08:15

a cada uno de los niveles que vas a ir a jugar 00:08:17

Mira, yo este es el nivel 1 00:08:18

y si pongo el nivel 2 00:08:20

pues ese HUD lo he arrastrado aquí 00:08:22

y el canvas está aquí y yo lo que hice 00:08:24

para guardarlo como un prefab fue poner 00:08:27

un parent, un empty 00:08:29

que se llamara HUD y dentro está todo 00:08:30

lo del canvas, incluido el event system 00:08:32

que tiene que estar siempre que hay un canvas 00:08:34

tiene que haber como mínimo un event system 00:08:37

en esa escena, ¿vale? Entonces 00:08:39

eso lo bueno que tiene es 00:08:40

que en realidad nosotros 00:08:42

vamos a ir jugando con este 00:08:44

HUD según el nivel, pero ya está 00:08:47

configurado siempre el mismo para arrastrarlo a todos 00:08:48

los niveles, ¿vale? 00:08:50

Entonces, ¿qué 00:08:52

tiene ese canvas? Pues lo que he dicho, 00:08:55

un campo de texto 00:08:57

que se irá rellenando con 00:08:59

el texto que nosotros vayamos diciendo, por defecto 00:09:01

pone player, ¿vale? Porque es lo que he puesto en el componente 00:09:03

de texto directamente y de momento 00:09:05

no se cambia, pero por código lo podremos 00:09:07

cambiar, está ahí preparado. Y luego 00:09:09

hay una imagen, ¿vale? Que 00:09:11

se ha situado, se ha ubicado en esta esquina superior derecha con, en este caso, a nivel 00:09:13

orientativo, vamos, a nivel que es como vamos a empezar el juego, las tres vidas, con esa 00:09:19

imagen, que es la que se está visualizando en este área, ¿vale? Que cuando vamos al 00:09:24

canvas, pues ahí está ese área de la imagen, ¿no? Ahí, a ver, me voy para atrás, ¿vale? 00:09:29

Ahí, epa, no quiere, ahí, ¿vale? Ahí tengo preparada esa imagen, ¿vale? Entonces, lo que yo he configurado directamente y voy dentro del prefab, ¿vale? Doble clic, a ver, en el prefab, doble clic, para que veas que coincide con lo que te estoy contando, ¿vale? 00:09:36

Entonces, yo ya en ese canvas, cada vez que meta este prefab, aparte en el canvas ya hay lo que yo he llamado un script llamado hood manager, un script como otro cualquiera, vaya, para que veas, está aquí, el hood manager, ¿vale? 00:09:53

Que yo lo he arrastrado al canvas. 00:10:08

¿Y eso qué es lo que nos va a permitir? 00:10:09

Tener más o menos centralizado todos los cambios o manipulaciones que hagamos dentro de ese canvas y los distintos elementos que tengamos, ¿vale? 00:10:11

Que aquí son uno de tipo texto y otro de tipo imágenes, pero en el menú configuración será uno tipo input de texto, ¿vale? De entrada de texto y otro de slider, ¿vale? Pero siempre van a estar dentro de este área que es el canvas, digamos, que marca el área de visualización de los elementos que vayamos introduciendo dentro, ¿vale? 00:10:18

¿Qué es lo que he hecho? Pensando en 00:10:38

Mismamente lo que tú has planteado 00:10:41

Es, vale, como tengo varias imágenes 00:10:43

Con los corazones según las vidas que me queden 00:10:45

Voy a hacer un array 00:10:47

¿Vale? ¿Y qué más cosas? 00:10:49

Yo, aquí es donde hay que irse planteando 00:10:51

Y ahora lo metemos por código, aquí ya está hecho 00:10:53

Pero es, yo en algún momento 00:10:55

Voy a querer manipular 00:10:57

El GameObject que tiene el componente 00:10:58

Texto, pues yo ya lo preparo 00:11:01

Mediante un 00:11:03

SerializeField o mediante un public 00:11:05

Ahora lo vemos en código. Una referencia a este texto que yo siempre podré cambiar por código. Es decir, que yo mediante código pueda entrar aquí, decir player y ponga Javi. Y ves que aquí ya se ve, se va actualizando. Lo he hecho ahora mediante el inspector, pero ya haciendo accesible estas áreas, estos componentes, puedo ir manipulándolo. 00:11:07

Igual he hecho con, digamos, la referencia, que esto es importante y puede que sea de hecho lo que te falte, la referencia al componente imagen, porque cuando cambiemos este componente imagen es cuando le diremos, oye, lo que tienes que cargar en este área que hay aquí es la imagen lives 2 o lives 1. 00:11:32

Entonces en algún momento vamos a necesitar referencia a esa imagen 00:11:53

Y luego hay otro preparado que esté menos importante 00:11:57

Que es uno de la bola de cada nivel 00:12:01

En cada nivel habrá un personaje al que vamos a influir 00:12:03

Según lo que guardemos en el nivel de dificultad 00:12:06

En menú configuración, esto ya es un poco más peleagudo 00:12:09

No sé lo que me voy a centrar ahora 00:12:12

Pues que esa pelota a través del código 00:12:14

Y habría que arrastrar en cada nivel 00:12:16

Luego habrá que arrastrar la pelota de ese nivel 00:12:18

Influimos en cosas como el peso de la masa 00:12:20

o la resistencia al aire que tiene su Rigidbody, ¿vale? 00:12:23

Esto te lo adelanto para enseñártelo aquí ahora a nivel de código, ¿vale? 00:12:27

Y empezamos. 00:12:32

¿Cómo es? 00:12:33

Porque creo que además es el punto menos complejo para mostrar esto, 00:12:34

que en el menú de configuración igual es un poco más... 00:12:39

Hay que dar más piruetas, que en realidad es lo mismo, 00:12:41

pero bueno, vamos a ir empezando aquí. 00:12:44

Si te fijas, los cuatro campos que yo ya he preparado en este prefab 00:12:47

del hud, el username, el lives array 00:12:53

el lives bola 00:12:55

yo ya los he preparado como cuatro variables 00:12:57

que son accesibles 00:12:59

desde el editor con esta serie de files 00:13:01

son privadas pero accesibles 00:13:03

desde el editor, esto ya lo hemos hablado varias veces 00:13:05

¿esto qué significa? que si yo voy a cualquiera 00:13:07

de los niveles y arrastro 00:13:09

al final yo 00:13:11

voy a tener estas áreas 00:13:13

y ves que en negrita está 00:13:15

este de bola porque es el único 00:13:17

digamos que yo he tenido que arrastrar la bola aquí 00:13:18

porque el resto, como siempre van 00:13:21

es decir, es el único elemento que no pertenece al canvas 00:13:23

como el resto 00:13:26

de elementos de la imagen 00:13:28

y de la entrada de texto, si van con el canvas 00:13:29

ya lo que se hizo es, en el propio 00:13:31

prefab 00:13:33

prepararlo, es decir, ya están asociados 00:13:34

el único que está vacío es el de la bola 00:13:38

¿vale? 00:13:39

entonces, ahí que es lo que se ha hecho, preparar 00:13:41

digamos todos los ingredientes que vamos a jugar 00:13:43

posteriormente 00:13:45

¿vale? hasta aquí me vas siguiendo 00:13:47

más o menos 00:13:50

un poco así 00:13:52

lo veo un poco complicado 00:13:52

pero 00:13:53

vale 00:13:53

pero vamos 00:13:55

más o menos 00:13:55

sí 00:13:56

en resumen 00:13:56

la idea sí 00:13:57

la idea sí 00:13:58

la cojo 00:13:59

pero 00:13:59

vale 00:14:00

como conclusión 00:14:00

para seguir 00:14:04

en resumen 00:14:04

lo que he hecho 00:14:05

es 00:14:05

preparar 00:14:06

todo aquello 00:14:07

a lo que yo voy a querer 00:14:08

afectar 00:14:09

mediante el canvas 00:14:09

en algún momento 00:14:10

ya está 00:14:11

yo voy a querer 00:14:12

que ese hud 00:14:13

en algún momento 00:14:14

cambie el texto 00:14:15

que pone ahí 00:14:15

que cambie la imagen 00:14:16

vale 00:14:18

luego aparte 00:14:18

Sí que hay que crear uno tipo sprite para meter, que este no es ningún componente, digamos, visible aquí ahora mismo, pero para meter las posibles imágenes que luego se van a cargar en el componente imagen, ¿vale? 00:14:19

Que está en el HUD también y luego aparte la bola que sirve para, ya te digo, cambiar la masa y el drag del RigidBody, ¿vale? 00:14:31

lo que se ha hecho es 00:14:42

el planteamiento es cada vez 00:14:45

que se cargue este HUD 00:14:47

y esto pasará en el start una vez 00:14:48

cada vez que se cargue el nivel que tiene el HUD 00:14:51

es decir, cuando arrancamos un nivel 00:14:53

se han creado tres métodos 00:14:55

que estos los he creado yo 00:14:57

es decir, son métodos que he creado yo, no es ningún update 00:14:59

que venga como el que solemos usar 00:15:01

sino son tres métodos distintos 00:15:03

que lo que hacen es arranca el nivel, vale, pues voy a mirar 00:15:05

voy a chequear cuál es 00:15:07

el nombre que hay guardado del usuario 00:15:09

que tengo que mostrar, cuál es el número de vida 00:15:11

y cuál es la dificultad del juego 00:15:13

en relación a 00:15:15

eso, a 00:15:17

los valores que estamos cambiando en el 00:15:19

body de la bola, ¿vale? 00:15:21

Vale. 00:15:24

Aquí, si te fijas, a continuación 00:15:25

están los voids preparados 00:15:27

con correspondientes a cada uno. Esos 00:15:29

cajones que lo que hemos hecho es, mediante 00:15:31

tres líneas, aludir a tres 00:15:33

bloques diferentes, ¿vale? Para que se ejecuten 00:15:35

siempre, dado que están en el start, 00:15:37

en el momento, ¿vale? 00:15:40

En el momento en el que en cada nivel arranquemos. ¿Y esto por qué se hace? Porque cuando damos a jugar en el menú inicial, ¿vale? A ver, voy aquí un segundo, voy al menú configuración, al inicial, perdón, al dar yo a jugar querré que coja, por ejemplo, la información que yo he guardado en nombre de usuario que afecta a la bola según lo que yo tengo en dificultad, ¿vale? 00:15:41

Y si es la primera vez que juego, porque no he pasado el juego, que no lo estamos haciendo así, pues que arranque con las tres vidas. Quiero que al arrancar cada nivel, chequee eso y me muestre la información que yo necesito en ese HUD y afecte de la forma que a mí me interesa. 00:16:10

Vamos con el primero, que no va a ser el primero que tengo aquí, sino el de actualizar las vidas. Este método lo que hace es el que define cuántas vidas va a mostrar como imagen. Cuando decimos vidas, hay que tener bien claro que salgan tres corazones. 00:16:28

una duda, perdona, una pequeña duda 00:16:53

entonces por lo que veo 00:16:56

todo se ha metido en el mismo hook 00:16:57

todo se ha metido en el mismo lado 00:16:59

tanto el nombre como lo de las vidas 00:17:00

como lo del tema de la pantalla de inicio 00:17:03

pantalla que pasa, opciones 00:17:06

todo se ha metido en el mismo 00:17:07

y luego lo que has construido son prefabs 00:17:08

por el tema de las vidas, por ejemplo 00:17:10

y metiéndolas cada una en su escena 00:17:12

no, bueno 00:17:16

a lo mejor es lo que quiero decir 00:17:17

pero tú has dicho que luego hago cada prefab 00:17:19

no, yo en el propio prefab 00:17:21

¿Vale? Ya he preparado todo eso. Es decir, este prefab, cuando lo arrastre, ya tiene un array con las cuatro posibles vidas, si te fijas. 00:17:23

Vale, vale, vale. 00:17:32

¿Vale? Siempre, en todos los niveles, de momento, vamos a tener la posibilidad de usar estas cuatro imágenes, porque ya va, digamos, unido a este código en el propio prefab. 00:17:32

Porque lo guardan en un prefab, claro. Si yo hubiera generado esto en un nivel y luego voy a otro y creo otro canvas y tal, pues habrá que hacerlo todo de primeras. 00:17:41

pero el prefab lo bueno es que me está agrupando 00:17:48

por eso ese icono de caja 00:17:50

me está empaquetando 00:17:52

toda esta información y el único que 00:17:54

dejo sin vincular, que por eso 00:17:56

pone none, es este de rigidbody 00:17:58

este que 00:18:00

está aquí, ese es el único que digo 00:18:01

este sí que va a ir con 00:18:04

algún elemento concreto del nivel que va a ser 00:18:06

la bola, el resto se van a ir 00:18:08

gestionando a través de un game manager 00:18:10

que ahora vamos a eso 00:18:12

entonces fíjate 00:18:14

que yo lo que he hecho 00:18:16

es un poco redundante pero es que esto es importante 00:18:18

que quede claro, lo que he hecho ya desde el propio 00:18:21

prefab que voy a ir arrastrando los niveles 00:18:23

es decir, vale yo ya sé 00:18:24

el array que va a ser de cuatro 00:18:27

elementos y he metido una imagen 00:18:29

en cada una de las posiciones 00:18:30

y lo lógico es jugar a nuestro 00:18:31

favor en esto y he hecho 00:18:35

que además el orden, el índice 00:18:36

del array que corresponde 00:18:38

coincida con el número de vidas 00:18:40

es decir, el de cero que coincida con el 00:18:42

de cero vidas, el de uno uno 00:18:44

porque los arrays, como ya se veía en el tema 00:18:46

de introductorio, ¿vale? Y si no le damos 00:18:48

una vuelta, siempre empiezan a contar 00:18:51

desde el cero la primera posición, ¿vale? 00:18:53

Es el primer índice. Entonces, hemos 00:18:54

conseguido, ¿vale? Y si no, incluso 00:18:56

si no hubiéramos tenido la imagen, 00:18:59

por ejemplo, esta no existiera, 00:19:01

hubiéramos metido hasta una imagen, a lo mejor aleatoria 00:19:02

o algún placeholder 00:19:05

para hacer que coincida con estos números, porque así 00:19:06

es mucho más fácil luego a nivel de programación 00:19:08

nosotros saber que en todo 00:19:10

momento si apelamos a la imagen 00:19:12

en lives tres o la guardada, mejor dicho, en el orden, en la posición tres de este array, pues es la de las tres vidas, ¿vale? 00:19:14

Y yo he arrastrado también en este momento, ¿vale? Esto se ha arrastrado una vez porque lo que he hecho ha sido decir, vale, 00:19:23

lo que es este campo, ¿vale? Que hace referencia al campo texto, ¿vale? A un tipo de variable texto. 00:19:29

Y ojo, esto es importante también, que lo pone en el tema, para cuando vayamos a usar por código métodos o clases o cualquier cosa referenciada con la UI, con User Interface, con los componentes de User Interface, hay que cargar una nueva librería, bueno, nueva, una librería que hasta que no ponemos esta línea no se carga, para no sobrecargar los scripts, que es este UnityEngine.ai, ¿vale? 00:19:39

Ya lo he hecho más veces, pero si yo, por ejemplo, no hubiera introducido esa línea, ¿vale? Al principio, antes de la declaración de clase, ¿vale? Directamente estos tipos de variable no me los cogería. 00:20:06

Y esto cuando hablamos de los componentes, recordad que hay tipos de variables que en realidad son los componentes. Que si yo pongo un tipo de variable llamado text, luego lo que podría hacer con esta variable es acceder a todo lo que hay, a todos estos campos, a todas estas propiedades que tiene un componente tipo text. 00:20:19

De hecho, fíjate en el icono, en esta T, que yo cuando doy a Canvas, solo me permite arrastrar, fíjate que está esa T ahí otra vez, solo me permite arrastrar con lo que corresponde con esa caja, que es un componente de tipo text. 00:20:40

Es decir, yo sé que este GameObject, entre sus diversos componentes, hay uno de tipo text, pues yo cuando arrastre este GameObject me va a coger el componente text y voy a poder, por ejemplo, acceder al espacio de text, de escritura que hay y cambiarlo. 00:20:54

pero eso lo hacemos porque estamos 00:21:13

digamos, introduciéndonos en ese componente 00:21:16

si yo en este que tengo 00:21:18

aquí, que es el que muestra la imagen 00:21:20

que no tiene un componente tipo text 00:21:22

¿vale? por mucho que yo me empeñe 00:21:24

a arrastrar ese game object 00:21:26

a donde me pide un componente tipo text 00:21:28

no me lo coge, porque solo 00:21:30

busca objetos que dentro 00:21:32

tengan este componente ya aplicado 00:21:34

si no, no sabe que coger 00:21:36

¿vale? que eso de hecho es el tipo 00:21:38

que reclama en el paréntesis que tiene 00:21:40

cada uno de estos 00:21:42

¿Vale? Entonces, yo cuando he arrastrado esta variable, lo que estoy consiguiendo es meterme por código, ¿vale? Cada vez que haga mención a este username text, me estaré metiendo en ese componente que he, en este caso, cogido a través del editor. 00:21:43

Y aquí cuando, por ejemplo, pone username.text, con minúsculas el text, es dentro del componente que hemos capturado, que tiene que ser de tipo text, el .text es una de las propiedades que lo que permite es directamente meter un string con lo que tiene que poner. 00:22:01

¿Vale? Si yo aquí en vez de player desconocido dijera prueba probando, ¿vale? Si yo no cambio, ¿vale? Ahora vemos esto. Si yo no cambio el texto en ningún momento, vas a ver que yo cuando arranque el juego se estará, a ver, voy a un nivel y luego arranco. 00:22:21

Cuando arranco el juego, va a poner player probando. ¿Y esto por qué? Porque al arrancar el juego, recordemos que al hacer un start, aplica estos tres métodos. Y dentro del de username, lo primero que pone es, si no existe, esto ahora lo explico, lo del game manager. 00:22:42

Si yo no he introducido un texto en el menú configuración, este que hay aquí que te he enseñado antes, ¿vale? Este de aquí. Si tú en ningún momento has variado este dato, ¿vale? Entonces ponme directamente lo que yo, es decir, si no existe ese dato, introdúceme en ese texto este player probando, ¿vale? 00:23:03

Si no, ¿qué haces? Pues vas a escribir en esta variable, en su propiedad de texto, pues este texto que está compuesto de la palabra player siempre delante, porque lo que queremos es decir así, en plan, queremos que ponga siempre jugador, dos puntos y luego el nombre que hayamos introducido. 00:23:25

si no, en este caso 00:23:43

que lo dejábamos vacío, porque no había nombre 00:23:45

pues ponía player solo, pero si no 00:23:47

lo que hará será coger el nombre que hayamos 00:23:49

guardado en el game manager 00:23:51

ahora vamos a ello, ¿vale? 00:23:53

¿hasta aquí qué tal? 00:23:56

sí, bien, bien, lo voy entendiendo, bien 00:24:02

una cosa, bueno, bueno, sigue, sigue 00:24:03

no, no, sí, sí, sí 00:24:06

pregúntame mejor si puede ser 00:24:07

vale, pues mira, había una forma de convertir en 00:24:09

el tema de la 00:24:11

para convertir en strings 00:24:14

los datos 00:24:15

que era una fórmula me parece 00:24:17

un método 00:24:19

para convertir 00:24:20

para tener algo convertido en strings 00:24:22

simplemente 00:24:24

ah bueno, sí, ya sé 00:24:27

de lo que me hablas, pero bueno 00:24:29

componerlo entre dos puntos 00:24:30

entre comillas, ya es un string 00:24:33

si creamos un string, aunque sea 00:24:35

este 00:24:37

era para convertir datos numéricos 00:24:38

por ejemplo, en un string 00:24:41

claro, es que te voy a dar dos formas 00:24:42

una, la fácil que es esta 00:24:45

que es que tú en cuanto tienes algo de clara como string, 00:24:46

aunque sea este vacío y le sumamos un dato numérico, ¿vale? 00:24:50

Porque esto, bueno, este no es numérico, 00:24:52

pero si fuera numérico, cuando lo estamos, digamos, sumando, 00:24:55

que es una concatenación, lo convierte a string, ¿vale? 00:24:58

Pero si no, el que tú estás diciendo es el método, 00:25:01

y espera que te lo busco aquí para no equivocarme, 00:25:05

porque la verdad es que de memorieta igual no te lo digo bien, 00:25:07

se llama toString. 00:25:11

a ver, ahí está 00:25:13

lo vamos a poner en Unity porque esto además se usa 00:25:15

mucho el lenguaje de programación 00:25:17

¿vale? 00:25:18

tú, si pones ese 00:25:19

ese 00:25:23

tuString, ¿vale? aunque este ejemplo 00:25:26

no es el mejor 00:25:29

un segundo, tuStringFormatting 00:25:30

es que quiero que veamos un ejemplo, pero sí, es tuString 00:25:33

lo que hay que hacer es meter dentro 00:25:35

del 00:25:37

tuString 00:25:38

el string, ¿vale? 00:25:40

queramos que convierta. 00:25:43

A ver, ¿por qué soundflop 00:25:46

toString? Cogemos... 00:25:47

Bueno, pero es que este ejemplo 00:25:50

no es el mejor. Pero vamos, sí. 00:25:51

Este es el que yo creo que queremos. 00:25:54

¿Vale? 00:25:57

Convierte un dato 00:25:57

a un string. 00:25:59

¿Vale? Entonces... 00:26:02

Pero ya te digo que si 00:26:04

ponemos una apelación a un string 00:26:05

y luego lo concatenamos con ese 00:26:07

número, lo convierte todo a un string. 00:26:09

Es una forma más rápida quizá, ¿vale? Hasta aquí, si más o menos me vas siguiendo, aunque ahora volvemos, lo que estamos haciendo es eso, acceder en cada caso, ¿vale? A los tipos de variables que hemos declarado arriba que hacen mención a componentes que hay en el canvas, ¿vale? 00:26:11

Luego, importante, y esto es uno de los kits de la cuestión en esta práctica con respecto a otras, ¿vale? 00:26:35

Porque es, digamos, la primera vez que lo ponemos en juego, que es el concepto de las variables estáticas, las static, ¿vale? 00:26:43

En el tema se explica que hay, de hecho, un tipo de variable que es tan representativo, a ver si me deja verlo, ¿vale? 00:26:50

que cuando llamamos 00:26:57

a ver, aquí lo tengo, a un script 00:27:00

igual que creamos los otros, lo llamamos así 00:27:02

escrito, ¿vale? Con G mayúscula y M 00:27:04

mayúscula, un script GameManager 00:27:05

hasta nos cambia el icono 00:27:07

y nos pone otro, ¿vale? Para tener bien 00:27:10

claro cuál es 00:27:11

porque es, digamos 00:27:13

la función que se debería dar, luego 00:27:15

cada uno escribirá dentro lo que quiera y 00:27:17

la tuerca está, pero digamos que este tipo 00:27:19

de script es una convención, este nombre de GameManager 00:27:21

para ir metiendo dentro 00:27:23

los comportamientos comunes del juego 00:27:25

a lo largo de todos los niveles, ¿vale? 00:27:30

Dependiendo del juego, a veces hay que hacer 00:27:32

mucho más scripts, digamos, game manager, 00:27:33

pero bueno, en uno como este, que es simple, 00:27:35

que tampoco alberga muchísimos datos, 00:27:38

pues se puede hacer en uno. 00:27:40

¿Y esto para qué lo usamos? 00:27:41

Ya os digo, esto de la tuerca es solo visual, ¿eh? 00:27:43

Cuando lo abro es igual que cualquier otro script. 00:27:45

Yo he borrado lo del start y el update, 00:27:48

pero es exactamente igual. 00:27:50

¿Y qué es lo que se ha hecho aquí? 00:27:51

Este script empieza igual 00:27:52

Se ha llamado GameManager 00:27:56

Y por eso lo llamaremos GameManager 00:27:57

Mientras lo usemos 00:27:59

Pero todas las variables que se han declarado 00:28:00

Son de tipo estática 00:28:02

Si te fijas 00:28:05

Y también las variables estáticas 00:28:06

Para que funcionen con el uso que les vamos a dar 00:28:08

Tienen que ser declaradas así 00:28:10

Static, public y luego ya el tipo de variable 00:28:12

Y el nombre, como siempre 00:28:14

¿Qué conseguimos con estas variables estáticas? 00:28:15

Que se pueda acceder a ella 00:28:19

a este script 00:28:21

siempre que queramos, ¿vale? Yo puedo ir 00:28:23

a cualquiera, a ver, 00:28:25

aleatoriamente estoy haciendo así, me meto en 00:28:27

Employer Manager o en Loves Things, ¿vale? 00:28:29

Y yo, si me meto en cualquier, 00:28:31

siempre hay que escribir, eso sí, dentro de un 00:28:33

método, ¿vale? 00:28:35

O de ejecución o un método que queremos nosotros, ¿vale? 00:28:37

Que si escribo aquí fuera, pues no 00:28:39

lo detecta. Si yo empiezo a poner 00:28:41

GameManager, me va a salir 00:28:43

GameManager como un objeto que ya existe, 00:28:45

¿vale? Como una clase 00:28:47

que alguien ha hecho 00:28:49

un programador, la vamos a tener 00:28:50

accesible siempre, ¿vale? Y cuando le demos 00:28:53

al punto, todas las variables 00:28:55

estáticas, aparte de otras que ya 00:28:57

vienen por efecto cuando tenemos una clase, 00:28:59

van a venir declaradas, y son 00:29:02

estas que tiene la cajita azul, las variables 00:29:03

si te fijas, ¿vale? Dificultad, 00:29:05

lives, username, coinciden 00:29:07

con las de, a ver, el game manager, 00:29:09

¿vale? Lives, username, dificultad, 00:29:11

¿vale? Para poder hacer esto, 00:29:13

es la única forma de poder acceder desde 00:29:15

cualquier punto sin tener que declarar 00:29:17

en el script completo, esa clase, ¿vale? 00:29:19

Es que las variables que tenga adentro sean de tipo static public. 00:29:23

¿Y esto para qué sirve? 00:29:28

Porque cuando, si vamos gestionando los juegos hasta ahora 00:29:31

en niveles independientes, aunque pasemos de uno a otro... 00:29:34

Una pregunta, una duda, te me acaba de surgir. 00:29:37

¿Tienen que ser siempre públicas o serializadas también? 00:29:39

No, tienen que ser públicas, ¿vale? 00:29:42

Porque vamos a recordar la diferencia entre el serialized field y el public. 00:29:45

Por ejemplo, y de hecho voy al que estaba enseñando antes, 00:29:49

cuando declaramos una variable así, que no pone public ni private, 00:29:52

no pone nada referente al ámbito, 00:29:57

lo que estamos haciendo es que se pueda ver en el editor 00:29:59

y poder arrastrar en el editor el tipo de variable, 00:30:02

pero sigue siendo privada. 00:30:05

Yo a esta variable no puedo acceder desde otros scripts. 00:30:07

Pero en este caso, yo sí voy a querer que se pueda acceder desde otros scripts. 00:30:11

básicamente este GameManager 00:30:16

no se va a aplicar 00:30:18

en ningún GameObject del juego 00:30:20

no es su función 00:30:22

este GameManager 00:30:24

al declararlo con variables 00:30:26

estáticas públicas, lo que va a hacer es ir 00:30:28

albergando información que vamos a poder ir guardando 00:30:30

digamos, por encima incluso 00:30:32

del juego, como por detrás 00:30:34

en otro punto, y que vaya guardando 00:30:36

siempre ciertos valores 00:30:38

entre los distintos niveles 00:30:39

para que aunque el juego 00:30:41

digamos, estamos en el nivel 1 00:30:43

arrancamos el juego, tened en cuenta 00:30:46

que eso, nosotros arrancamos el juego 00:30:48

y nos metemos en configuración, aquí hay un 00:30:50

dato que pone Daniel, que yo 00:30:52

esa información la tengo que guardar en algún sitio 00:30:54

para que cuando yo vaya a otro nivel 00:30:56

a otra escena que carga otras cosas 00:30:58

siga conservando la información guardada 00:30:59

¿vale? es como un guardado 00:31:02

aparte de los niveles 00:31:03

de manera independiente a los niveles 00:31:06

¿vale? por eso es útil 00:31:08

los game managers, porque aquí, por ejemplo 00:31:10

en tu caso, que estás intentando poner 00:31:12

el volumen de la música, cuando tú pones 00:31:14

la música, al ir cambiando de nivel 00:31:16

hay que ir, digamos 00:31:18

metiendo diferentes 00:31:20

variables, es decir 00:31:21

distintos componentes de música en cada 00:31:24

nivel, o hay que hacer 00:31:26

algunas operaciones de que no destruya ese componente 00:31:27

porque al cargar el nivel, si aquí no hay 00:31:30

un 00:31:32

objeto, un GameObject que tenga 00:31:33

el componente 00:31:35

del AudioSource, que entiendo que es el que 00:31:37

estabas poniendo, no se va a oír la música 00:31:40

y aunque tuvieras otro, a lo mejor el volumen 00:31:42

de cada uno se irá variando según cada nivel 00:31:44

con esto conseguimos que siempre 00:31:46

por código podemos decir 00:31:48

vale, yo en este nivel de configuración 00:31:49

he puesto Daniel y yo de alguna 00:31:52

manera lo que voy a hacer es 00:31:54

en este campo de static public 00:31:55

que la información que alberga 00:31:58

aquí es Daniel 00:32:00

y yo después desde otro script de otro nivel 00:32:01

pues puedo decir, oye 00:32:03

cárgame lo que en algún 00:32:05

en la última vez que se ha guardado algo 00:32:07

en esta variable estática 00:32:09

me lo muestras 00:32:11

sobre todo me interesa que estés entendiendo 00:32:12

el objetivo 00:32:15

de esto, de estas variables 00:32:17

estáticas, las variables estáticas 00:32:19

para que puedan ser accesibles 00:32:21

desde cualquier otro 00:32:23

desde cualquier otra clase 00:32:24

es decir, de cualquier otro script 00:32:28

es eso, dime 00:32:30

mira, entonces 00:32:31

porque si hay una variable estática que se crea 00:32:33

que va a funcionar durante todo el juego 00:32:35

en todas las escenas, porque se va a mantener siempre igual 00:32:37

¿por qué no se hace todo el script 00:32:39

de antes, el que más se ha hecho al principio 00:32:41

porque nos hace directamente la estática 00:32:43

y ya ese se arrastra a todos los demás 00:32:45

porque 00:32:47

nosotros, es decir 00:32:49

para empezar 00:32:51

estas variables estáticas se pueden 00:32:53

declarar también en otros 00:32:55

en otros scripts 00:32:57

pero lo que queremos es 00:32:59

centralizar sin tener que aplicar 00:33:01

el game manager, tú ten en cuenta que 00:33:03

y esto pasaba al principio 00:33:04

si hacíamos un script 00:33:06

y luego no lo arrastrábamos a un game object 00:33:09

no se aplicaba ese script, es decir, si yo a este 00:33:11

Kanban no le arrastro este script 00:33:13

¿vale? no va a hacer 00:33:14

nada de lo que hace, porque no está en el nivel 00:33:17

lo que sí se puede 00:33:19

hacer es que cuando tenemos variables 00:33:21

estáticas públicas, no hace falta, este GameManager 00:33:23

no lo estoy arrastrando a ningún GameObject 00:33:25

da igual, porque digamos que son variables 00:33:27

que están a otro nivel 00:33:29

por supuesto que también se podrían declarar 00:33:30

¿vale? es decir, yo también podría declarar 00:33:33

esas tres variables que tengo en el GameManager 00:33:35

en otro script 00:33:37

Pero es verdad que si lo centralizamos en un GameManager, todo lo que sea común al juego lo tenemos unido, ¿vale? Y si lo mezclamos con otros comportamientos que sí que tienen que estar aplicados al juego, estaríamos como mezclando, por un lado, lo que es universal para el juego con lo que en este caso, por ejemplo, afecta al HUD, que es un GameObject específico, ¿vale? Entonces, es mezclar cosas que no se deberían. 00:33:39

además es que esto no es referente a ningún nivel 00:34:03

concreto, lo del hood manager 00:34:06

por ejemplo este rigidbody, si es 00:34:07

concreto de cada escena que habrá que decirlo 00:34:10

y el 00:34:12

estos campos si que se están 00:34:12

digamos dando acceso a que se pueda 00:34:16

modificar por código lo que hay en estas 00:34:18

variables, pero si que hace referencia 00:34:20

a algo específico que está en la escena 00:34:22

esto son información que se 00:34:23

guarda y luego nosotros vamos a 00:34:26

cargar en algún punto 00:34:28

¿vale? 00:34:29

esto de momento lo que me interesa es que entendamos 00:34:30

hasta aquí 00:34:34

vale, vale, entonces 00:34:34

las variables estáticas realmente son 00:34:37

sencillas, porque tú haces este game manager 00:34:40

y empiezas a hacer las variables que tú quieras 00:34:42

sabiendo qué tipo de datos vas a necesitar 00:34:43

guardar a lo largo del juego 00:34:46

y las dejas ahí preparadas, vale 00:34:47

y vuelvo al hand manager 00:34:49

ahora que he explicado esto, porque 00:34:51

por ejemplo, si yo no 00:34:53

he cambiado nada, es decir 00:34:56

si yo no he introducido, bueno 00:34:57

importante, claro, cuando declaramos 00:34:59

estas variables estáticas, si aquí no le decimos 00:35:01

que esto valga 3, ¿vale? 00:35:03

3 vidas por defecto o lo que quisiéramos 00:35:05

recordad que 00:35:07

significa que valen 0 o nada 00:35:09

es decir, si son variables 00:35:11

numéricas como este int o como este float 00:35:13

valen 0 y si es un 00:35:15

string, no es que valga 0 00:35:17

sino que vale, esto ya lo hablamos un día, vale 00:35:19

esto, esto no es 00:35:21

un espacio, que sería esto, esto es 00:35:23

igual a nulo, ¿vale? 00:35:25

Se conoce como un nulo. 00:35:27

Esto significa que este campo, aunque la caja existe, 00:35:29

lo que está albergando es un valor nulo. 00:35:33

No tiene nada dentro, ¿vale? 00:35:35

Lo digo porque hay que entender que hasta que no se guarde una información, 00:35:37

vale o cero o nulo. 00:35:41

Entonces, aquí, por ejemplo, esto se podría hacer de otra forma. 00:35:43

He puesto lo de nulo aquí por ver cómo se hace. 00:35:46

Se podría hacer de otra forma. 00:35:48

Pero si al arrancar un nivel, uno de los niveles, 00:35:49

que son los que cargan este HUD, 00:35:53

se mete aquí en el start y dice 00:35:55

a ver, vamos a ver, actualizar el username 00:35:57

el nombre que yo le he puesto porque yo he decidido 00:35:59

se mete y dice, a ver, si 00:36:01

este GameManager 00:36:03

y ves que estoy referenciando directamente 00:36:05

a la variable estática pública esta que tenemos 00:36:07

en el GameManager, si 00:36:09

el username no hay nada 00:36:11

porque no se ha cambiado nada en ningún 00:36:12

momento, se ha guardado otro valor en el menú 00:36:15

config, lo que 00:36:17

voy a enseñar es 00:36:19

entrando 00:36:20

en este componente 00:36:22

que yo he referenciado aquí por el editor 00:36:25

me meto en su parámetro 00:36:26

text y pongo player 00:36:28

porque nadie ha cambiado nada, entonces pongo un valor 00:36:30

por defecto, por eso 00:36:32

aquí ahora cuando voy al juego 00:36:34

a ver 00:36:36

cuando voy al juego 00:36:37

no escribo nada y juego 00:36:40

pues pone player 00:36:42

lo que pasa es 00:36:43

que si yo por el contrario 00:36:46

ya he introducido algún valor 00:36:48

en este username 00:36:50

Lo que va a hacer es coger ese username text y lo que va a escribir ahí. Y cuando digo ahí, para que quede claro, por si acaso, me meto en un nivel que tenga el hud, que es lo que estamos viendo ahora. Me meto en el hud y lo que va a hacer es meterse aquí. 00:36:52

Y cuando hago ese test.text, lo que hago es directamente modificar lo que pone ahí. Es decir, aquí lo que estoy haciendo es meterme en ese componente y en su propiedad text, eso hace referencia a este text de aquí, lo que yo ponga a continuación del igual es lo que se escribirá en esa caja. 00:37:09

¿Y qué es lo que escribo? Pues este player, porque quiero que siempre ponga player, como hemos dicho antes, y aparte después, pues lo que se haya guardado, ¿vale? Que además es de tipo string, ¿vale? El username es de tipo string, ¿vale? Pues lo va a poner a continuación. 00:37:27

¿Con eso qué conseguimos? Evidentemente todavía no hemos configurado el menú configuración, pero significa que yo de algún modo lo que introduzca aquí, ¿vale? Pongo José Luis, por poner un nombre que no sean los que pongo siempre. 00:37:41

José Luis, ¿vale? Y cuando yo suelto, aquí hay otro script que está guardando en ese game manager, en su variable username, ¿vale? Pues está guardando José Luis. Y ahí está, ya no es nula el username, ahora es José Luis. 00:37:58

por eso cuando yo juegue me va a poner ese player 00:38:13

y aquí me está cargando 00:38:16

lo que se había guardado aquí 00:38:17

y de hecho también se ve 00:38:20

más fácil, por si acaso es más fácil 00:38:21

entenderlo así, se ve que en username 00:38:23

ha puesto player José Luis 00:38:26

porque es lo que hemos puesto aquí 00:38:27

¿vale? que lo escriba ahí 00:38:29

¿sí? 00:38:31

Sí, sí, eso lo he puesto yo también, eso me ha salido 00:38:35

cuando en los juegos que he hecho yo 00:38:37

lo he puesto 00:38:39

Es decir, que tú lo que es el game manager 00:38:40

y el funcionamiento del texto 00:38:42

Sí que lo tenías dominado, ¿no? 00:38:44

Por ir 00:38:46

Sí, eso 00:38:46

Vale 00:38:47

Sí, eso 00:38:47

He puesto bien eso 00:38:49

He puesto en las opciones 00:38:50

Me pasa a una siguiente pantalla 00:38:51

Vale 00:38:53

Y entonces, bueno 00:38:54

Ahora te lo enseñaré cuando pueda 00:38:54

Y luego el return 00:38:56

Vuelvo otra vez para atrás 00:38:57

Luego de un kit 00:38:58

Lanzaconsola 00:39:00

Vale, sí 00:39:02

Ese 00:39:03

Lanzaconsola 00:39:04

Eso es 00:39:07

Vale, sí 00:39:08

Eso del application 00:39:10

Sí, eso es 00:39:11

Lo que te he comentado 00:39:11

Ya lo ponía 00:39:12

Ya pone que es hasta que no se te ocurra 00:39:12

tenga el build, el juego no 00:39:14

funciona, ¿vale? Pero bueno, que se puede dejar 00:39:16

preparado. Entonces, vamos a ir, si te parece, 00:39:18

con el de los sprites, 00:39:20

¿vale? Que es el que tenía dudas. 00:39:23

¿Sí? 00:39:25

Vale. El HUD Manager, 00:39:27

según arranca el juego, 00:39:29

¿vale? El número 00:39:31

de vidas está en cero, 00:39:32

¿vale? Porque, de hecho, estas vidas 00:39:35

que es un int, 00:39:36

en el config no hay ningún punto, ¿vale? 00:39:38

Tal y como está estructurado en el enunciado 00:39:40

y tal, no hay ningún punto que nosotros decidamos 00:39:42

con cuántas vidas se departen y cuántas 00:39:44

vidas son máximas, ¿vale? Nosotros estamos dando por 00:39:46

sentado que son un máximo 3. 00:39:48

Es la mecánica de juego que queremos. Y aquí, 00:39:50

cuando declaramos esta variable, que alberga 00:39:52

la información global que hemos dicho, 00:39:54

¿no? De supra... 00:39:56

por encima del juego, ¿no? La forma de decirlo 00:39:58

esto vale 0, ¿vale? Así que cuando 00:40:00

arrancamos el juego, vale 0 en lives. 00:40:02

¿Cómo se ha hecho esto? 00:40:05

Pues que al... 00:40:07

A ver... 00:40:08

No, este no es. Este. 00:40:09

Al actualizar las vidas, lo primero que se dice, vale, 00:40:12

si las vidas que hay en el GameManager son cero, es decir, 00:40:14

como está por defecto, directamente yo quiero que el valor del GameManager 00:40:18

vidas valga tres, ¿vale? 00:40:22

Y lo que se hace es, ¿vale? 00:40:24

Ya vale tres. 00:40:26

Es decir, aquí se ha creado una variable nueva, ¿vale? 00:40:27

Esta no existía, de tipo in, que son las vidas, ¿vale? 00:40:30

Es decir, esta variable solo va a existir en este ámbito de lives. 00:40:33

¿Y qué es lo que va a hacer esto? 00:40:36

guardar el número 00:40:38

que tengan las vidas en cada momento 00:40:41

¿vale? cuando empezamos 00:40:43

GameManagerLives vale 3 00:40:44

así que lives pasa a valer 3 00:40:47

¿qué es lo que estamos haciendo? 00:40:49

y esto seguramente sea la parte liosa y ahora 00:40:51

le damos las vueltas que haga falta, pero 00:40:53

tengo aquí 00:40:54

una referencia ¿vale? que teníamos 00:40:56

aquí al componente imagen 00:40:59

que es el que carga la imagen ¿no? 00:41:00

es el que está en el GameObject y aparte 00:41:02

hay que meter 00:41:05

el sprite, es decir 00:41:06

si yo voy a lives image 00:41:09

el punto sprite se refiere 00:41:10

al source image, es la imagen que metemos 00:41:13

aquí, que es un sprite, hay que meterlo como un sprite 00:41:15

entonces 00:41:17

lo que estamos haciendo aquí es diciendo 00:41:18

dentro de la variable que hemos 00:41:21

arrastrado aquí en el editor 00:41:22

dentro del sprite que muestra 00:41:24

méteme la imagen 00:41:26

correspondiente al array que yo he configurado 00:41:28

antes, este que tenemos 00:41:31

aquí, hay un 00:41:33

tipo de clase que de hecho 00:41:35

no es del arte.y porque se usa 00:41:36

en más contextos, a diferencia de text o image 00:41:39

que son componentes de la UI 00:41:41

propiamente dicha, los sprays 00:41:42

se usan como contenedor de 00:41:45

imagen, ¿vale? Y esta se usa 00:41:47

también en 2D, etc. Se ha hecho 00:41:48

este array, ¿vale? Que ya en el propio 00:41:50

prefab del hub, ¿vale? 00:41:53

En el propio prefab, ya habíamos 00:41:55

que esto también lo habías hecho tú por lo que me has comentado 00:41:57

habíamos arrastrado 00:41:59

a ver, en el canvas 00:42:01

habíamos arrastrado los cuatro posibles 00:42:02

prefabs vale la posición cero de la raíz es muerte la de uno es una vida la de vale así hasta tres 00:42:05

el componente imagen va a servir para cargar en cada momento una imagen la que sea yo por 00:42:11

defecto vale como yo porque sé que estoy creando el juego no tú en tu caso sé que 00:42:30

la imagen que quiero que haya cuando arrancó el juego sea la de 3 no pero 00:42:36

nosotros aquí lo que vamos a ir es de las imágenes vale este de hecho este 00:42:41

iconito que aquí es el de sprite vale aquí podemos ir arrastrando sprites 0 1 00:42:46

ves que aquí la imagen y voy a poner un nivel para que lo veamos aplicado 00:42:51

Nivel 1, ¿vale? Esta imagen va a ir variando según la que yo arrastre a esa imagen. Digamos que el componente image lo que hace es cargar una imagen y lo que vamos a hacer es jugar con el array para decirle cuál tiene que cargar de las que hemos metido en ese array. 00:42:58

¿vale? 00:43:13

entonces 00:43:15

para 00:43:15

a ver, voy aquí 00:43:18

eso, yo aquí puedo ir arrastrando 00:43:20

y ves que aquí se verá, y de hecho en la ejecución 00:43:23

del juego, cuando se muera y se quite 00:43:25

una vida, en el image 00:43:27

va a ir mostrando un diferente 00:43:28

un diferente 00:43:30

sprite, ¿vale? 00:43:32

una cosa es el componente image y otro 00:43:34

el sprite que se mete como 00:43:36

imagen que se muestra, son dos cosas 00:43:38

distintas, ¿vale? 00:43:40

Y es verdad que al principio lía un poco. Yo cuando arranque este nivel, de hecho, vas a ver que automáticamente, aunque yo he arrastrado aquí el lives 0, ¿vale? Cuando le dé al play se va a poner el de 3, ¿ves? ¿Por qué? Porque yo tengo definido que cuando arranque el juego, al empezar este nivel, ¿vale? Si no he, recordemos, si no he variado en ningún momento y no lo he hecho, lo que guarda el game manager en su variable de vidas, como es 0, me pone 3, ¿vale? 00:43:42

Ahora mismo este dato lo que alberga es un 3, un int, un número entero 3, ¿vale? Cuando empieza el juego decimos el número de vidas, otra variable, son 3. ¿Y qué es lo que hacemos? Y esta es la clave, ¿vale? Y le damos, lo repasamos varias veces si quieres. 00:44:09

hay la alusión al componente imagen 00:44:24

y le decimos, vale, dentro de ese componente imagen 00:44:28

dentro del sprite, es decir, con esto 00:44:31

lo que estamos haciendo referencia ahora mismo es 00:44:33

a este hueco que hay aquí, a este campo 00:44:35

lo que pongamos después de este igual 00:44:38

significará el sprite que va a cargar aquí 00:44:42

y tiene que ser un sprite porque este tipo de parámetros 00:44:45

solo admite sprite, solo admite imágenes 00:44:48

seleccionar sprite, de hecho, lo pone ahí 00:44:51

entonces lo que habrá que hacer es cargar un sprite esto es muy importante 00:44:53

siempre saber qué tipo de variable es la que va en cada sitio dentro de el 00:44:59

componente imagen y el campo de search image que se escribe como sprite aquí 00:45:03

tiene que ir algo de tipo sprites por eso hemos creado aquí en algún momento 00:45:08

una variable de tipo sprites vale porque no carga imágenes imágenes es del 00:45:12

componente lo que carga son sprites que es como se llama las imágenes realmente 00:45:16

¿Vale? Entonces, aquí lo que se le dice es, cárgame de los sprites que he guardado dentro de la variable life array, ¿vale? Recordad que poniendo estas dos llaves después del tipo de variable se dice que puede albergar varios valores porque es un array, ¿vale? 00:45:20

Y luego, para llamar al contenido que hay aquí, hay que poner el nombre de esa variable y dentro de las llaves la posición o índice, ¿vale? Del array que vamos a cargar. 00:45:41

Entonces, ahora mismo, cuando arrancamos el juego, estamos diciendo, vida son tres, ¿vale? Tres, tres. Este es el valor que se está guardando, ¿vale? 00:45:54

Y entonces, como aquí tengo albergado un 3, va a decir, en este momento, ¿vale? Cárgame en la imagen del array de sprites que tengo el que esté en la posición 3. Por eso al arrancar el juego siempre me va a enseñar la imagen que esté en el elemento 3, ¿vale? 00:46:02

Si yo aquí dijera, cárgame, ¿vale? Lo manipulo, ahora esfuerzo que siempre enseñe el 1, ¿vale? Pues ahora siempre que arranque, siempre que arranque el juego, incluso aunque aquí yo he cargado en el editor antes de darle al play y antes de que se haga todo lo que está en el start del script, ¿vale? 00:46:21

Yo arrastré el lives cero, lo que va a hacer es mostrar el de solo una vida, porque le estamos forzando a que del array que hemos configurado solo me enseñe el de una vida. Lo que vamos a ir haciendo en cada momento es que cada vez que se reinicie el nivel, ¿vale? En este start, al hacer estas operaciones, me va a ir enseñando lo que esté guardado en la variable lives. 00:46:39

y siempre va a coincidir con el número de vidas 00:47:01

porque si empieza el juego 00:47:04

vale 0 y lo pasa a hacer 3 00:47:06

¿vale? pero 00:47:08

nosotros lo que tendremos que ir haciendo es que 00:47:09

cuando nos vayamos 00:47:12

muriendo en el precipicio 00:47:14

lo que vamos a hacer es cada vez que nos caemos 00:47:15

el game manager vidas 00:47:18

le resta una vida 00:47:20

entonces ahora en ese 00:47:21

game manager si nos hemos caído una vez 00:47:23

game manager lives 00:47:26

valdrá 2, se guarda en todos los niveles 00:47:27

resetea el nivel y el hand manager 00:47:30

cuando vuelve a leer todo lo que 00:47:31

está aquí, todos los métodos 00:47:34

que tiene que arrancar al principio 00:47:36

que tiene que interpretar al principio 00:47:37

pues va a decir, vale, vale 00:47:39

dos, si game manager lives 00:47:42

vale cero, le pongo esto, no, vale 00:47:43

dos, así que sigo, y aquí 00:47:46

lo que hace es guardar en lives lo que valga 00:47:48

en ese momento, que es dos 00:47:50

y que es lo que va a hacer aquí, mostrar 00:47:51

la posición dos de la array 00:47:53

de imágenes, de sprites 00:47:55

¿vale? que es la de 00:47:58

las dos vidas, porque aquí esto 00:47:59

en ese momento pasará a valer 00:48:01

dos, que me vuelvo a caer 00:48:03

y se reinicia otra vez el nivel 00:48:05

pues nuevamente en precipicio de las 00:48:07

dos que había se restará una 00:48:09

¿vale? y aquí volverá a hacer 00:48:11

otra vez toda la operación, a ver 00:48:13

¿vale cero o no? ¿vale? pues entonces 00:48:15

lo que guardo es uno, que muestro 00:48:17

la raíz de sprites que 00:48:19

tenía, el que corresponde con uno 00:48:21

que me vuelva a caer y vuelvo a 00:48:23

restarle uno y se encuentra con cero 00:48:25

Pero ya está configurado para que si ese Game Manager vale cero, ¿vale? Para empezar, cuando volviera a cargarse el nivel, las vidas serían tres, volvería, nunca mostraría la vacía, ¿vale? Pero aparte es que ya está forzado para que cargue el nivel de inicio, ¿vale? Voy a jugarlo un segundo y lo vemos. 00:48:27

espera, voy a empezar de hecho 00:48:48

desde el menú de 00:48:52

inicial, bueno, he cambiado 00:48:54

el sprite que hay por defecto 00:48:57

aunque como por código se actualiza 00:48:59

pues se cambia solo, pero 00:49:00

yo ahora mismo al jugar 00:49:02

como el número de vidas era cero, me lo ha puesto 00:49:04

a tres, ¿no? por lo que hemos visto antes de 00:49:06

esto que tenemos 00:49:08

aquí, ¿vale? y me ha cargado 00:49:10

el array tres, por consecuencia, si yo me 00:49:12

caigo 00:49:14

choco con un 00:49:15

con un 00:49:19

collider 00:49:21

que está configurado con otro script 00:49:23

para que reinicie el nivel y le reste una vida 00:49:26

al lives del 00:49:28

game manager 00:49:30

ya me ha puesto dos, que yo me vuelvo a caer 00:49:31

me pone uno 00:49:34

que yo me vuelvo a caer no me va a poner cero vidas 00:49:35

lo que hace es que como un game over 00:49:38

yo ya me he salido del juego 00:49:39

ahora mismo habría cero vidas 00:49:41

realmente en el game manager lives 00:49:44

cuando arranco otra vez como vale cero 00:49:46

me lo pone en 3 y así infinitamente 00:49:48

entonces ya 00:49:50

lo bueno es que si yo pierdo una vida 00:49:52

gracias a esa variable estática pública 00:49:53

yo ahora mismo tengo 2 vidas 00:49:56

y al cambiar de nivel lo que me carga 00:49:58

son las 2 vidas y no las 3 00:50:00

que pasa cuando tengo 0 00:50:02

¿vale? lo que hemos hablado es que va 00:50:04

entre niveles guardando 00:50:06

los valores 00:50:08

¿vale? ¿qué tal hasta aquí? 00:50:09

bueno yo si sigo jugando 00:50:13

pues eso 00:50:14

Sí, sí. Vale, vale. 00:50:15

Sí, esa es la idea. 00:50:16

Entonces, cuando tú metes un image, 00:50:18

lo que se hace es, 00:50:19

búscame la referencia de estos sprites, 00:50:21

es lo que le estás diciendo más o menos. 00:50:22

Claro, el problema es la nomenclatura, 00:50:24

porque image parece que se refiere a imágenes, 00:50:27

y sí, se refiere más que a imágenes 00:50:29

al reproductor de imagen, vamos a decirlo así. 00:50:31

Las imágenes en sí, 00:50:34

lo que son las imágenes en sí, 00:50:36

se llaman sprites, 00:50:37

y tienen otro tipo de variable también, ¿vale? 00:50:38

Y eso es lo que hay que cargar 00:50:41

dentro del componente image, un sprite. 00:50:42

Pero no ha habido que, por ejemplo, en el vídeo de Álvaro lo que se hace es, que es otra forma de hacerlo, según lo que se va viendo, según lo que se busque en cada momento. 00:50:45

Pero yo puedo tener, claro, aquí lo que estamos haciendo es sombrear los niveles. 00:50:59

Él lo que hacía era, y voy a cargar el de tres, él lo que hacía era coger un sprite, a ver, por ejemplo, cogía esto y lo que él explicaba, si no me equivoco, 00:51:04

es que iba, que también se puede cambiar por código, 00:51:13

poner otro tipo de imágenes, que es como considerar 00:51:16

que todo el área de la imagen que hemos metido 00:51:19

se puede manipular y se puede hacer un recorte. 00:51:22

Entonces, cuando pierdo una vida, lo que hago, 00:51:25

en vez de cargar otra imagen que solo tiene los dos corazones, 00:51:27

no es otra imagen, estoy variando otro valor 00:51:31

que es que puedo recortar esta imagen hasta aquí. 00:51:33

Que pierdo otra vida, pues le digo, me meteré otra vez 00:51:36

en el componente image y me meteré en fill amount. 00:51:39

De hecho, mira, si yo, por ejemplo, me meto en livesImage, que es el que está referenciando a ese componente, habrá otro que se llama fillAmount. Y yo con esto puedo decirle que esto valga 0.75. Bueno, lo estoy escribiendo de pena. Igual a 0, que no estaba mirando. 0.75. 00:51:42

¿Vale? Si yo, de hecho, fíjate, ahora arranco el juego, ¿vale? Y lo pongo en 1, cuando arranque el juego, no me lo está haciendo porque no se estará cumpliendo la condición. 00:52:04

pero a ver, espera, la hicimos filamón, a ver, estoy accediendo a él, ah bueno, es que no he guardado, que leches, vale, a ver, ahora sí que debería hacerlo, vale, ves que se ha puesto por código, si es que lo bueno de poder acceder a los componentes es que ya podemos acceder a cualquier cosa que tenemos aquí, con saber, con ver cómo se llama cada cosa aquí, ya sabemos que se puede ir poniendo aquí, 00:52:16

Por ejemplo, yo que sé, yo sin tener ni idea digo fill method, ¿vale? Pues aquí habrá, como estoy dentro del componente image, ¿vale? Pues habrá un, ¿vale? Mira, aquí está. Habrá un tipo de propiedad que es fill method, luego hay que ver qué es lo que permite hacer, ¿vale? Pero eso permitirá entre estas opciones, pues cambiar entre estas en ciertos momentos que a nosotros nos convenga en tiempo de ejecución, ¿vale? 00:52:47

¿Qué tal hasta aquí? Más o menos se va entendiendo. A ver, simple, ¿vale? Simple porque lo que vamos a hacer es cargar imágenes una tras otra, varias, y entre esas se van cargando. 00:53:12

Vale, entonces 00:53:28

Esto resuelto más o menos 00:53:31

Espera que yo no sé si sigues estando 00:53:35

A ver 00:53:36

Vale, bueno, me pone que estás 00:53:38

No me contestas, pero 00:53:43

Voy a ir a 00:53:44

Por lo que me has ido diciendo 00:53:47

Los botones ya los tenías configurados 00:53:49

En el 00:53:51

Menú inicial 00:53:53

Voy al menú configuración 00:53:55

Que probablemente sea lo más complicado 00:53:57

¿Vale? 00:53:59

Si nos fijamos, esto ya no es el HUD, esto es otro canvas, ¿vale? Que hay aquí, pues que hemos configurado con un image que hemos cargado, otro sprite que es el de este fondo para que ocupe todo el fondo. 00:54:01

Hemos puesto un slider, ¿vale? De los distintos componentes que puede haber en la UI. Pues en el tema se explican, ¿vale? Aquí esto sería un slider, que es el slider. 00:54:12

Y esto viene del tema, tiene diferentes subapartados. Uno para configurar, por ejemplo, el handle que es, en este caso, esta bola, el manejador que sirve para identificar qué se arrastra. Luego, cuál es el área que está rellena. Si yo voy avanzando aquí, veréis que hay una zona roja y otra verde. 00:54:23

Pues el fil área es lo que está relleno, lo que se ha modificado y el background se refiere a la parte que está sin marcar del slider, ¿vale? Como va de izquierda a derecha, cuando digo sin marcar me refiero a que no se ha completado, ¿vale? 00:54:42

bueno 00:54:58

Javi creo que te has 00:55:00

desconectado, pero bueno, lo que me importa de esto 00:55:02

es que esos 00:55:04

diferentes 00:55:05

elementos 00:55:07

de GameObjects, de UI 00:55:10

¿vale? 00:55:12

tienen sus propias propiedades y esa es la gracia que tienen 00:55:14

que el botón, por ejemplo 00:55:16

este botón de volver, cuando nos metemos 00:55:18

tiene en la parte 00:55:20

inferior 00:55:22

unos métodos, digamos 00:55:23

por eso tiene esos paréntesis 00:55:26

que permiten hacer acciones sin tener que hacer mucho esfuerzo. 00:55:27

Por ejemplo, este onClick, lo que significa, los botones vienen así configurados, 00:55:31

es que cuando yo hago clic en ese botón, puedo arrastrar cualquier script, 00:55:35

que en este caso se ha arrastrado uno que se llama canvas, que se ha hecho aquí, 00:55:40

que se llama, no, perdona, loadScene, que básicamente lo que se ha hecho es arrastrar este script ahí. 00:55:45

Es un script que ni siquiera está aplicado a ningún object, 00:55:53

Se ha arrastrado directamente al botón y entonces ese botón, ese load the scenes, que lo abro aquí, está configurado simplemente. A ver, y aquí algo he tocado. Ah, bueno, estaba así. 00:55:55

Lo que configura es un método. Y ojo, para que lo detecte ahora en las posibilidades que ofrece este tipo de eventos, de métodos eventos que tienen las distintas interfaces, es que luego nos podemos meter dentro de las funcionalidades que tiene ese script que hemos adjuntado. 00:56:08

Y ahí, por ejemplo, uno referente a los métodos que hemos creado nosotros, ¿vale? Con un botón, por ejemplo, podemos decir que este GameObject, pues por ejemplo, se active o se desactive, ¿vale? Y entonces yo cuando le doy aquí, lo que puedo hacer es que se active o se desactive un nivel, ¿vale? 00:56:28

Porque lo que estamos haciendo es que este canvas, ahora por ejemplo he cogido el canvas y se ha arrastrado ahí, que esto haga que se active y se desactive el canvas. 00:56:48

Claro, cuando se activa y se desactiva el canvas, lo que sucede es que se deja de ver. A ver, cuando lo toque, pues se va y se ha desactivado todo el canvas. 00:56:56

Es decir, se puede manipular multitud de cosas diciendo que cuando se haga clic en ese botón, pues pasen cosas. 00:57:05

Por ejemplo, yo en este loadScenes se ha generado un método, y para que se vean, vuelvo a decir, tienen que ser métodos públicos, un método llamado loadScene, que se parece un poco al nombre de la clase, del script, pero no es exactamente igual. 00:57:12

Ahora nos fijamos que si la escena en la que estamos es la 1, cuando le damos a ese botón, lo que hará... 00:57:26

A ver... Ah, bueno, vale. Fijaos que lo que hemos hecho es ponerle un parámetro también. 00:57:39

Bueno, espera, es que no quiero adelantarme, pero cuando cargamos este load scene, cuando arrastramos este script load scenes, 00:57:45

¿Vale? Aquí nos va a permitir ver las funciones que haya declaradas públicas. Aquí ahora mismo, como da error, ¿vale? Pues no se ve. Pero si yo vuelvo aquí con esto bien arrastrado, a ver, ¿vale? Y ojo, ¿vale? Perdona, que esto no lo he dicho. Para poder arrastrarlo, primero tiene que estar en un GameObject, ¿vale? Tiene que estar en un GameObject. 00:57:55

Yo lo he arrastrado aquí, pero no tanto para que se aplique desde este GameObject, sino para poder arrastrarlo desde aquí, ¿vale? 00:58:18

Y aquí que pueda decir, vale, de los scripts que tengo aquí activos, que me cargue este, ¿vale? 00:58:27

Entonces, ¿qué es lo que estamos consiguiendo? 00:58:35

Al arrastrar este canvas, podríamos decir, por ejemplo, quiero que accedas a los métodos del otro script que hay aquí arrastrado, ¿vale? 00:58:37

Que es el config menu. 00:58:43

Pues yo, si busco aquí, habrá otra referencia, config-menu. Y aquí enseñará los métodos, que muchos ya vienen por defecto, son los que vienen, todos los métodos públicos que haya dentro de ese script que estemos referenciando. 00:58:44

En loadTheScene, si os fijáis, está el método loadTheScene que habíamos creado aquí. Por eso yo lo puedo buscar dentro de loadTheScene y ver loadTheScene. Se ven los métodos públicos que hay. También hay otro salir que está ahí creado, que también es público y por eso sale ahí. 00:58:58

Si yo pusiera esa función de salir, lo que hará este botón cuando le demos a volver es un application quit, que es que se quitaría el ejecutable. 00:59:14

Entonces, a ver, espero que borra algo que no debía. 00:59:27

Lo que se puede hacer es no solo decir que se ejecute lo que hay dentro como en este salir, sino, como ya vimos, incorporar un parámetro. 00:59:30

¿Y qué significa eso? 00:59:39

Que nosotros, en cualquier momento, con este script, cuando carguemos su método público, loadScene, nos va a permitir pasar un valor aquí. ¿Y qué valor es ese? Si no hubiéramos puesto este parámetro, aquí no saldría nada, como pasaba antes con salir, que simplemente ejecuta salir, no hay más opciones. 00:59:41

Si vamos, de hecho, y voy a hacer otro ejemplo, si yo voy poniendo aquí más parámetros, por ejemplo, int scene y aparte, no sé si va a admitir más de uno, flow número dos, yo que sé, en principio debería permitir, a ver, voy a load the scenes, vale. 01:00:01

Bueno, en otras funcionalidades se podría. 01:00:23

Solo permite un máximo de un parámetro, ¿vale? 01:00:26

Pero hay otras funcionalidades que se pueden incluso pasar varios parámetros y dejan distintos campos. 01:00:29

Esto pasa, por ejemplo, en los eventos de animación también se podrían hacer este tipo de cosas. 01:00:33

¿Pero qué permite esto? 01:00:38

Que cada vez que tengamos un botón y arrastremos un objeto que tenga este script cargado, ¿vale? 01:00:39

A ver, que no he debido de guardar. 01:00:49

Efectivamente. 01:00:51

Si yo en el botón arrastro el objeto canvas y yo busco dentro de lo que tiene el script loadScenes con su variable, con su método, perdón, loadScenes, ves que entre los parámetros hay uno que va a pedir de tipo int, que es ese que hemos creado que se llama escena, int escena. 01:00:52

y ahí nosotros 01:01:16

podemos ir diciendo 01:01:18

que vaya la escena, en este caso 01:01:19

cero, creo que si no me equivoco 01:01:22

porque la escena de las que tenemos aquí 01:01:23

la escena en los build settings 01:01:26

la cero es la del menú inicial, es decir, yo voy a 01:01:28

querer que vuelva al dar el botón 01:01:30

al menú inicial, que ojo 01:01:31

que si yo pusiera la uno, iría al nivel 01:01:34

uno, vamos a hacer la prueba 01:01:36

si yo le doy a 01:01:37

aquí, al botón 01:01:39

vuelvo al 01:01:42

menú inicial, si yo 01:01:43

rápidamente dijera que este botón 01:01:45

a donde me tiene que llevar es al nivel 1 01:01:47

porque es el índice de los 01:01:49

build settings, ¿vale? 01:01:51

Ahí estoy haciendo referencia al nivel 1 01:01:53

de los build settings, ¿vale? 01:01:55

Ahora cuando arranque el juego y le dé 01:01:57

al volver a donde me lleva es al 01:01:59

nivel 1, fijaos. 01:02:01

O si pusiera el 2, el 3, etc. 01:02:03

¿Y esto por qué? 01:02:05

Lo voy a poner 0, que es el que nos interesa 01:02:07

porque aquí 01:02:09

lo que pasamos es 01:02:11

un número, que es el que ponemos en el inspector 01:02:12

si la escena 01:02:15

es igual a 1 01:02:17

aparte quiero que en 01:02:18

este game manager 01:02:21

omnipresente 01:02:22

que hablamos, ¿no? siempre 01:02:25

si es la escena 1, recordad que es 01:02:26

la escena de que empieza el juego 01:02:29

y ahí siempre queremos empezar el juego 01:02:31

con las vidas a 3 01:02:33

guardaría ese nivel de vidas en 3 01:02:34

para que nuevamente 01:02:37

toda la lógica de esos sprites 01:02:38

pusiera la posición 3, el índice 3 de los distintos arrays. 01:02:40

Pero bueno, esto es como algo circunstancial en caso de que se diera esa condición. 01:02:46

Lo importante es que lo que va a hacer es, y recordemos, para el gestor de imágenes 01:02:49

hay que usar la librería de Scene Management, lo que vamos a decirle es que cargue la arcena 01:02:53

correspondiente al número que hemos escrito en el inspector, que en este caso será la 0, 01:02:57

que es la del menú inicial. Entonces es muy fácil con estos botones, con una configuración como esta, 01:03:02

Por ejemplo, ir al menú inicial y si os fijáis de los tres botones que se han puesto, dos, ¿vale? Si voy a los dos botones, dos tienen exactamente el mismo load scenes y lo que se va variando en cada botón sin más esfuerzo es la función que coge y según el parámetro va a un nivel o a otro cada botón, ¿vale? 01:03:08

El play uno, el play va al uno y además pondrá la vida a tres, que es lo que hemos visto antes en este config y al nivel cinco, que es este nivel, ¿vale? Según se ha configurado en los build settings. Y bueno, y el otro, el otro botón, el de kit, también con el mismo script de load the scenes, pues está aludiendo, hemos puesto que aluda al otro método, ¿vale? 01:03:32

Porque recordemos que en lo de scenes, aparte de verse el log que viene por defecto, pues también estaba el de salir. Entonces, con un solo script, que eso sí, recordad, hay que cargar en algún elemento, que es el que arrastramos aquí, ¿vale? Es decir, que hay que cargar algún game object, ¿vale? Hay que arrastrarlo. 01:03:57

no se puede arrastrar directamente 01:04:15

el script desde el inspector 01:04:18

no se puede hacer 01:04:19

a ver, esto por ejemplo no se puede coger 01:04:20

el loads of scenes que tengo aquí 01:04:24

¿vale? y decir 01:04:25

una pregunta 01:04:30

esto no debería funcionar 01:04:32

bien, dime 01:04:34

mira, una cosa 01:04:36

por ejemplo, he visto que 01:04:37

has arrastrado el canvas entero 01:04:40

¿puedes arrastrar 01:04:41

una parte del canvas o tiene que ser entero 01:04:44

todo. Hay que arrastrar 01:04:46

el elemento del canvas que tenga 01:04:48

el script que vas a usar. 01:04:50

El elemento del canvas. Si arrastras el 01:04:52

canvas entero, la pues le alfarda, 01:04:53

¿no? Entiendo. No, no. De hecho, estoy 01:04:56

arrastrando el canvas entero. 01:04:58

Esto es como 01:05:00

cuando antes arrastraba 01:05:01

en el HUD. Me estoy quedando sin voz, perdona, 01:05:03

que igual en algún momento empiezo 01:05:06

a ronquear. 01:05:08

Me voy al HUD, ¿vale? Que habíamos configurado. 01:05:10

Si te fijas, ¿vale? 01:05:12

Cada uno de estos elementos que vamos 01:05:14

arrastrando tiene un color, un 01:05:16

iconito, ¿vale? Esto depende 01:05:18

de que yo estoy arrastrando 01:05:20

un GameObject, pero yo de ese GameObject 01:05:21

luego cojo una parte, un componente 01:05:24

¿vale? Entonces da igual 01:05:26

que GameObject sea, si al final lo que va 01:05:28

a coger de ese GameObject es el script 01:05:30

load the scenes, fíjate en el icono este 01:05:32

del asterisco 01:05:34

Sí, sí, va a coger el que está asociado al script 01:05:34

Solo va a coger el asterisco, bueno, por defecto 01:05:38

coge todo el objeto, ¿vale? Mira, fíjate 01:05:40

yo arrastro el canvas y está 01:05:42

el objeto, lo que pasa es que como nosotros sabemos que 01:05:44

En ese canvas pusimos ese script, que esta es la clave de los botones. 01:05:46

Nosotros en la función nos podemos ir metiendo, fíjate, en todos los componentes que tenga ese objeto. 01:05:50

Es decir, estos son los distintos componentes, el transform que tiene siempre, red transform, canvas, quédate con los nombres. 01:05:57

Porque yo arrastré el objeto canvas y yo ahora aquí puedo meterme en red transform, canvas, en todos sus parámetros y cambiarlos. 01:06:04

entonces se pueden hacer un montón de cosas 01:06:12

la cosa es que también tenemos un script 01:06:15

con dos variables públicas 01:06:17

que permitan hacer eso 01:06:19

pero ojo, nuevamente, ¿vale? 01:06:20

como ejemplo 01:06:23

yo puedo, ese script 01:06:23

de, a ver que me 01:06:27

vuelvo loco a veces un poco 01:06:29

de load the scenes, ponerse la event system 01:06:30

por decir algo, ¿vale? se lo agrega ahí 01:06:32

¿vale? y yo lo que hago 01:06:34

en el botón es decirle, vale 01:06:37

yo quiero que cojas del event system 01:06:39

dentro de todo lo que tiene 01:06:40

load the scenes 01:06:42

y load the scene 01:06:43

la 5 01:06:45

y ya está 01:06:45

porque realmente 01:06:46

el game object 01:06:47

es algo 01:06:48

recordad 01:06:49

del primer día 01:06:50

que un game object 01:06:51

es simplemente 01:06:52

un empty 01:06:53

¿vale? 01:06:55

con un transform 01:06:55

eso sí tiene 01:06:56

lo del game object 01:06:57

y un transform 01:06:58

¿vale? 01:06:58

pero luego le vamos poniendo 01:06:59

los componentes 01:07:00

que es lo que hace 01:07:01

que un game object 01:07:01

se vaya convirtiendo 01:07:02

en unas cosas 01:07:03

o en otras 01:07:04

¿vale? 01:07:04

entonces da un poco igual 01:07:05

que está aquí 01:07:06

o en cualquier sitio 01:07:07

sí que hay que 01:07:08

Meterlo en algún objeto 01:07:09

Porque aquí solo permite meter objetos 01:07:12

Porque yo no puedo 01:07:14

Se puede, ¿vale? Pero va a dar problemas 01:07:15

No se puede cargar directamente 01:07:17

Desde el panel de proyectos 01:07:20

Los assets 01:07:23

Tiene que ser desde la jerarquía 01:07:23

¿Vale? De la escena concreta en este caso 01:07:26

¿Vale? Esto a diferencia del game manager 01:07:28

Si que alude a elementos que están 01:07:30

Dentro del nivel 01:07:32

Por eso el game manager 01:07:34

Ese script que está como afuera 01:07:35

Ese script sí que no hay que 01:07:38

No hay que vincularlo 01:07:41

Como componente a nada 01:07:43

Simplemente pues 01:07:44

Está guardando datos 01:07:46

Que son, como su propio nombre indica 01:07:48

Estáticos durante todo el juego 01:07:50

¿Vale? 01:07:52

Lo voy a poner aquí 01:07:54

5, vale 01:07:56

¿Qué tal hasta aquí? 01:07:57

Bien, bien, bien, perfecto 01:08:02

Entonces esto también nos da 01:08:04

Nos da 01:08:06

Para ir más allá, aunque no es lo que se 01:08:08

pide, nos da la posibilidad, fíjate, 01:08:11

de decir, mira, este fondo 01:08:13

si yo lo desactivo o lo activo, ¿vale? 01:08:15

Es el fondo de la imagen. 01:08:17

Imagínate, yo digo que cuando le dé al botón 01:08:19

config, en vez de ir a otro nivel, 01:08:21

lo que hago es que ese fondo, arrastro el game 01:08:23

object, ¿vale? Yo digo que 01:08:25

ese game object 01:08:27

haga un setActive, que es un método 01:08:27

que sirve para activar o desactivar, ¿vale? 01:08:30

Es análogo, ¿vale? Es análogo 01:08:32

a dar a este botón. setActiveTrue es 01:08:35

que está activo, setActiveFalse es que 01:08:37

está inactivo. Ves que aparece y desaparece. 01:08:39

y también digamos que se 01:08:41

desaparece aquí 01:08:43

digo porque tiene un montón de posibilidades 01:08:44

el setActive 01:08:48

como hemos visto 01:08:49

setActive tiene un parámetro de bool 01:08:50

según el bool es 01:08:53

true o false 01:08:55

lo que 01:08:57

conseguimos con esto es que 01:08:59

si yo arranco el juego 01:09:01

y le doy al botón config 01:09:03

que es en el que estoy poniendo esto 01:09:04

si yo clico lo que hago es poner en false 01:09:06

el SetActive de este objeto fondo. 01:09:09

Fíjate, yo le doy al juego, empieza, 01:09:12

porque como de momento no he clicado en ningún lado, 01:09:15

yo cuando le doy a Config no va a ir, 01:09:17

porque en ningún momento se lo estoy diciendo, 01:09:19

no estoy yendo a otro nivel. 01:09:20

Lo que estoy diciendo es que desactive, 01:09:22

ahora vas a ver qué ocurre, ese GameObject fondo 01:09:24

y por tanto se va a dejar de ver. 01:09:26

Fíjate, cuando le doy al botón, placa. 01:09:28

Desactivado, porque lo ha puesto en falso. 01:09:31

Ha puesto este SetActive en falso. 01:09:34

Con los botones se puede acceder a prácticamente todo. Es decir, los botones son una forma más o menos directa de ejecutar cosas. Es verdad que mediante el inspector, aunque hay que ir haciendo métodos, se puede acceder a cualquier valor de otro objeto, arrastrándolo ahí simplemente. 01:09:37

Diciéndole, vale, al darle a click, pues listo. 01:09:55

De hecho, hay un apartado, esto es bastante más, 01:09:58

no es más avanzado, pero es otra cosa, 01:10:04

que es en los botones sale el onclick, 01:10:06

pero nosotros podemos decir, ponerle un componente event trigger 01:10:08

y decirle que sea cuando, yo qué sé, cuando el puntero entre. 01:10:11

Y aquí lo que haremos será arrastrar un objeto. 01:10:17

Mira, de hecho, fíjate, voy a poner que en este botón, 01:10:20

y ya estoy añadiendo un comportamiento que no es propio del botón, 01:10:23

que sí que viene con el onclick, 01:10:27

le estoy diciendo que a este elemento, 01:10:28

que sí que se restringe a lo que es el botón, 01:10:32

a este config y ese área, 01:10:34

voy a decir que cuando entre el puntero, 01:10:36

pues que ahí sea cuando cambie de nivel. 01:10:39

Es decir, ahora mismo está configurado 01:10:42

que cuando clico en configuración desaparece el fondo. 01:10:45

Y le voy a decir que no. 01:10:47

Bueno, es decir, no que no. 01:10:49

Que cuando, yo qué sé, a nivel 5. 01:10:51

que cuando yo, el puntero 01:10:54

lo meta en config, ¿vale? sin tener que clicar 01:10:56

ya no me va a dejar de hacer lo otro 01:10:58

porque es que va a pasar directamente al nivel 01:11:00

5, a la escena 5, ¿vale? 01:11:02

de los build settings, vamos a ver si lo hace 01:11:04

yo estoy aquí, ¿vale? 01:11:06

el puntero se acerca, placa, placa, placa 01:11:08

y no voy a clicar, ¿eh? 01:11:10

fíjate, hace la acción que yo le vaya diciendo 01:11:12

y fíjate que aquí hay unas cuantas 01:11:14

¿vale? que se pueden ir diciendo 01:11:16

cuando se 01:11:18

cancela, que es cuando se suelta 01:11:20

cuando se da el click 01:11:21

Es decir, cuando el puntero entra por encima, cuando se arrastra, cuando se mantiene pulsado, cuando se selecciona, cuando se mueve. Hay muchos tipos de comportamientos que son eventos en sí con este event trigger, ¿vale? 01:11:24

Lo que hace la OSUIS es dar ya componentes con este tipo de eventos ya como predispuestos, porque se entiende que un botón la gracia que tiene es que lo pulsas, por eso es el onclick. Y aquí voy de hecho a lo siguiente, que es para ver la lógica de cómo funciona. 01:11:37

Bueno, no sé muy bien qué cambios he hecho, pero si yo me meto en otros tipos de componentes como son ese slider, cuando yo me meto en el slider, fijaos que es un poco la misma lógica, pero en vez de un clic lo que pone es cuando se cambia el valor. 01:11:56

Es decir, en cuanto yo haga algún cambio de valor arrastrando esto, pues se va actualizando un valor que hemos puesto en un script llamado configMenu, que de hecho está aquí, que es el que configura todo y guarda, entre otras cosas, la dificultad del slider. 01:12:14

Que la dificultad del slider no deja de ser este valor que hay aquí. Esto se conecta con eso. Entonces, con esto lo que hacemos es que actualizamos el slider. Hay un menú, hay un método, igual que hemos hecho antes, público, que sirve para cambiar los valores del slider. 01:12:34

Y que también guarde en la dificultad de juego del GameManager la dificultad de ese valor para que durante todo el juego tenga esa dificultad, ¿vale? Y por ver el otro ejemplo, cuando vamos al input de texto, lo que tiene aquí es otro evento que es cuando se cambia el valor. 01:13:00

Es decir, mientras yo no toque nada, no existe nada. Era un nulo, recuerda. Pero cuando yo empiece a escribir, cada vez que cambie ese valor, voy a aludir al método updateInput, que lo que hace es meter en el username de ese GameManager estático el texto que yo haya introducido en este input. 01:13:26

Está ejecutando este método. Cada vez que cambie un valor, se estará cambiando el valor del username y ya se irá cargando donde corresponda, como hemos visto antes. 01:13:47

Y luego, de hecho, hay otro que es que no sea, es decir, dejar esto vacío y que sea cuando deje de escribir y clique fuera, que sea cuando se guarde, para que no sea en cuanto pulse cualquier tecla ya que funcione. Es decir, este es un poco más, es decir, procesa menos. Tampoco son procesamientos muy complicados, pero hasta que yo no deje de escribir, pues no se guarda el valor de lo que se introduzca. ¿Vale? ¿Qué tal? 01:13:57

bien, sí 01:14:23

entiendo la mecánica 01:14:26

más o menos la entiendo, ahora hay que ponerla en práctica 01:14:28

pero bien, eso es lo que más me interesa 01:14:30

porque luego ponerla en práctica es verdad que tiene tela 01:14:32

es decir, tienes que darle vueltas 01:14:34

y poco a poco, etcétera 01:14:36

¿vale? pero sobre todo 01:14:38

es interesante ver 01:14:40

en base a qué funcionan los elementos 01:14:41

de la UI y en muchos casos 01:14:44

es por estos eventos que hay aquí, ¿sabes? 01:14:46

no sé si tienes alguna duda más, más allá de 01:14:49

en principio no, era simplemente 01:14:52

el tema este, luego 01:14:55

entiendo que luego, porque como ha habido un momento que se me ha ido 01:14:57

la cobertura, el nivel de 01:14:59

ahora ya estoy con el portátil 01:15:01

el nivel de dificultad 01:15:02

lo vas poniendo con 01:15:05

por ejemplo con el 01:15:07

drag, con la masa, con todo lo demás 01:15:08

entiendo 01:15:11

y eso además lo he puesto en el HUD 01:15:12

porque como va a ir siempre los niveles 01:15:15

que van con la bola, los jugables 01:15:17

pues lo he puesto en el canvas del HUD 01:15:19

Pero si me meto en el HUD Manager, por ejemplo, ¿vale? Se va actualizando esa dificultad, ¿vale? Y en el update peso, ¿vale? Lo que se ha dicho es, guárdame en una variable float de dificultad la dificultad que hay en el Game Manager, ¿vale? 01:15:20

La dificultad al final está unida al slider y va del 0 al 3, ¿vale? 01:15:37

Porque en el slider que te he enseñado antes, a ver, en el slider que te he enseñado antes, 01:15:42

se ha configurado para que vaya, a ver, espera, que tengo, no, el slider es este, perdón. 01:15:48

Sí, lo tenías de 0 a 3. 01:15:54

De 0 a 3, ¿vale? 01:15:55

Y aparte, bueno, esto es una tontería, pero para que, como estos son diversos niveles, 01:15:56

si se ponen whole numbers va de uno en uno, pero en realidad es un float, ¿vale? 01:16:00

Si te fijas aquí el valor, ¿vale? 01:16:04

Si se pone como whole numbers, pues hay como gradaciones, ¿vale? 01:16:06

Va de uno en otro, ¿vale? 01:16:10

Pero al final lo que guarda es un float, ¿vale? 01:16:12

Para que se te quede eso en la cabeza. 01:16:13

Mira, cuando leo los apuntes, te pone que a la hora de configurar 01:16:19

en el slider, tienen que ser íntegros, números enteros, ¿no? 01:16:23

Sin embargo, yo entiendo que se refiere a eso, 01:16:27

a poner un mínimo y un máximo, pero tiene que ser un float 01:16:30

porque lo guardan por decimales también, puede ser por decimales. 01:16:32

Mira, te lo enseño, ¿vale? Y además esto está muy bien que me lo hayas dicho. Perdóname, ¿eh? Vale, el UpdateSlider, que al final es el método que se ha generado, ¿vale? El UpdateSlider es este método que se actualiza al principio, pero luego se va actualizando según movemos el slider, ¿vale? 01:16:35

Fíjate que es el que tenemos. A ver, aquí, ¿vale? El que se está llamando es el updateSlider, ¿vale? Es ese método. Cada vez que mueva ese slider, se ejecuta esto, ¿sí? 01:16:59

Entonces, cuando se ejecuta, hemos hecho una variable que recoja el valor del slider. Pues si el slider está en la altura del 1, pues guarda un 1. 01:17:11

Pero fíjate que lo que está guardando es un float, ¿vale? Por lo que te he dicho, porque el slider tiene infinitos decimales, ¿vale? 01:17:20

Si no marcas este whole numbers, fíjate. 01:17:26

Eso me lo haría. 01:17:29

Sí. 01:17:30

Entonces, lo ponemos en whole numbers porque son cuatro niveles de dificultad lo que se configura. 01:17:31

Y para eso, de hecho, se ha hecho una string de textos de dificultad, 01:17:36

que luego se han generado los cuatro niveles de chupado fácil, normal y difícil. 01:17:42

Son cuatro posiciones y, por tanto, son números enteros. 01:17:47

No existe el chupado y medio. 01:17:51

Es o cero, o uno, o dos, o tres. 01:17:53

Entonces, aquí cogemos el valor del float, del slider, en el que estemos. Pero es verdad que para cargar uno de estos índices, aquí lo que va es un número entero. Son cuatro posiciones de números enteros. 01:17:56

Entonces hay que hacer lo que se llama una conversión implícita. No, implícita no, explícita de hecho. Esto ya lo dije en su día, pero normal que se os haya olvidado. 01:18:14

que es que nosotros podemos convertir un float en un int, es decir, lo que hace es redondearlo, ¿vale? 01:18:28

Haciendo esto, este parámetro. Ahora se ha hecho aquí una especie de variable nueva que es un int, ¿vale? 01:18:36

Y lo que hace es guardar como un int realmente el valor del slider que era un float, pero convertido a int, ¿vale? 01:18:42

Realmente redondea la baja, si no me equivoco. Si tiene un decimal, se lo carga y ya está. 01:18:50

¿Y qué es lo que hace? Que el slider, el texto que hemos puesto aquí a la derecha, este texto digamos que se ha añadido como otro texto, es decir, es un texto normal que se ha colocado vinculado a este script para que vaya junto, 01:18:54

pero en realidad esto es un texto, es un UI text. 01:19:14

Perdona si ya digo tonterías, pero es que llevo hablando tanto rato 01:19:22

que tengo la cabeza hecha un lío. 01:19:24

Nada, no te preocupes. 01:19:26

Una cosa, mira. 01:19:27

Vale, dime. 01:19:28

Y mira, otra cosa, perdona que pregunte tanto. 01:19:30

No, no, no, sin problema. 01:19:32

Que te iba a decir, y que te haga hablar tanto. 01:19:34

No, no, no, sí, pero bueno, que a veces me trabo ya porque, 01:19:36

pero bueno, sí, dime. 01:19:40

el tema está en que 01:19:40

haces un array también con el tema del nivel de dificultad 01:19:43

es decir, lo vinculas 01:19:46

a cada parte del slider 01:19:47

con un array según una cadena de texto 01:19:49

no, es más simple 01:19:51

realmente no se crea un array 01:19:53

relacionado con el 01:19:55

decir, sí y no 01:19:58

el array que se hace es de los cuatro 01:19:59

de los cuatro nombres 01:20:01

que tienen que mostrar 01:20:03

no tiene nada que ver con números 01:20:04

el array son de cuatro strings 01:20:06

que es lo que estaba explicando, que es el texto que va a poner aquí. 01:20:09

Si el slider tiene un valor de 1, pone fácil. 01:20:13

Si es el de 0, es chupado. 01:20:16

De hecho, fíjate, yo a medida que voy moviendo ese slider, 01:20:18

se va cambiando el texto para que el usuario tenga una referencia 01:20:22

de qué significa cada nivel. 01:20:28

Entonces, lo que se ha hecho es un array de textos 01:20:30

y luego 01:20:34

lo que se vincula es 01:20:36

que lo que ponga en ese texto 01:20:38

porque aquí hay una variable de dificultad texto 01:20:39

que es lo mismo que hemos hecho antes 01:20:42

que es que en el canvas 01:20:44

dificultad texto se ha arrastrado 01:20:46

este texto que hay aquí, fíjate 01:20:48

y entonces accedemos 01:20:50

a este campo de texto 01:20:52

y le decimos que el texto que ponga ahí 01:20:53

que lo que haga es 01:20:56

cogerme el texto 01:20:59

y según el valor que tenga el array 01:21:01

vale, dificultad key, dependiendo 01:21:03

de eso, como ahora es número entero, me enseña 01:21:05

o chupado, fácil, o normal, o difícil 01:21:07

¿sí? es decir, si aquí 01:21:09

es texto dificultad y el valor 01:21:11

fuera de cero, me enseña chupado 01:21:13

si fuera de dos, enseñaría normal 01:21:15

es lo que está haciendo, vaya 01:21:17

y luego aparte, es decir 01:21:18

esta línea sirve para ese texto 01:21:21

para llegar al componente de texto y cambiar 01:21:23

el nivel 01:21:25

del texto que pone como nivel 01:21:26

pero realmente está cargando 01:21:28

en relación al slider porque 01:21:31

se lo estamos diciendo como 01:21:33

un array, pero vaya 01:21:34

que realmente donde estamos guardando el valor 01:21:36

del array como dato numérico 01:21:39

es nuevamente 01:21:41

en el game manager 01:21:43

y ese 01:21:44

dificultad 01:21:46

lo que hacemos luego en el 01:21:49

head manager es 01:21:51

lo que hace es 01:21:52

guardar en una variable 01:21:54

esa dificultad que se ha definido 01:21:56

según dejáramos el slider 01:21:59

Y según eso, los cuatro valores posibles, aquí también se podría hacer un switch, pero bueno, se ha hecho con ifs. Si la dificultad fuera cero, es decir, la de chupado, pues la bola, recuerda que habíamos accedido al rigidbody de esa bola, a su componente rigidbody, pues la masa, y vuelvo al nivel, la masa de esa bola que hemos referenciado, o el drag irá cambiando. 01:22:01

Y ya según eso, el comportamiento físico. 01:22:34

Entonces, con esto, dependiendo del nivel que hayamos guardado en el Game Manager, 01:22:36

cuando se cargue el HUD, al iniciar dice, a ver, ¿qué peso me ha llegado hasta este momento? 01:22:40

Y mira ahí, a ver, pues en el Game Manager me pone que es nivel 2. 01:22:46

Y entonces la bola tendrá una masa y un drag. 01:22:49

Y ahora más fácil o más difícil el juego, porque sobre todo en los niveles en los que la plataforma se gira, 01:22:53

no la propia bola, sino la plataforma 01:23:00

claro, dependiendo del peso y la resistencia al aire 01:23:02

caerá más o menos rápido 01:23:04

entonces pues si cae a toda leche 01:23:05

porque tiene más masa, la dificultad más alta 01:23:07

y además poca resistencia al aire, es decir 01:23:09

que no lo frena casi nada 01:23:12

pues va a toda leche, entonces es más complicado 01:23:13

meter la bola en el agujero 01:23:16

¿vale? 01:23:18

Sí, sí, vale, fácil 01:23:22

Vale, bueno 01:23:24

esto, es decir, es muy 01:23:25

complejo, yo lo sé, pero bueno 01:23:28

es que si no se explican el tema 01:23:30

y no se pone en juego, pero bueno, yo creo que 01:23:33

dándole vuelta así con lo que 01:23:35

estamos viendo hoy, sobre todo me importa, aunque no 01:23:37

lleguéis al 100% de lo que se pide 01:23:39

si llegáis a un 75% 01:23:41

pero lo estáis entendiendo bien 01:23:43

pues de lujo, sobre todo es que lo entendáis 01:23:45

pues ya está, muy bien 01:23:47

vale, no sé 01:23:49

si tienes alguna duda más 01:23:51

si quieres 01:23:52

te abro el trabajo que tengo 01:23:55

porque ahora sí que estoy con el perpátil 01:23:56

Vale, sí. Pero sobre todo, perdón, antes de que deje de compartir, lo esencial es saber que siempre podemos acceder a los componentes. Lo digo porque da mucho miedo lo de los scripts, pero realmente lo que estamos haciendo es, igual que si aquí pusiéramos 8, lo estamos haciendo por código. 01:23:58

Entonces es simplemente arrastrar, ¿vale? Pues en el HUD, arrastrar a qué vamos a afectar y ya a partir de eso, si apelamos a esa variable, es como entrar a los campos. 01:24:17

vale, mira, esta es la 01:24:30

para que lo vayas viendo 01:24:31

he hecho el canvas, juego de la pelota 01:24:33

le he titulado y tal, entonces yo le doy 01:24:36

aquí 01:24:37

empiezo 01:24:38

vale, entonces esto es como hasta ahora 01:24:40

los corazones has visto que los tengo arriba 01:24:44

lo que pasa es que 01:24:46

ya está, no se me quitan 01:24:47

no soy capaz de quitarlo, vale 01:24:49

hay que cargar, digamos 01:24:50

los sprites, lo que hemos visto 01:24:53

claro, yo lo que había hecho ahí era 01:24:57

bueno, luego la siguiente parte 01:24:59

el menú de opciones 01:25:01

con un retool 01:25:02

y entonces en consola 01:25:10

el kit por ejemplo 01:25:12

lo tengo aquí 01:25:15

lo he mandado a consola para salir 01:25:15

que entiendo que luego se podrá hacer 01:25:18

claro, ahí hay que poner el application.kit 01:25:19

método 01:25:22

eso aquí no se ve 01:25:23

hasta que no se tiene un ejecutable 01:25:26

no puede quitar el ejecutable 01:25:27

porque aquí sería que quita Unity 01:25:29

entonces no lo hace 01:25:30

Y la parte de opciones la he hecho 01:25:32

de la siguiente manera, como cuando 01:25:34

llegas a opciones, 01:25:36

te cambia 01:25:37

a otro canvas diferente, 01:25:40

lo he metido aquí en 01:25:42

opciones. 01:25:44

Lo suyo, a ver, se puede hacer con 01:25:46

un canvas, 01:25:48

pero lo suyo es que hagas otro nivel. 01:25:50

Otro nivel que sea otra. 01:25:53

O sea, yo cada vez que te iba enseñando... 01:25:54

Otra escena. 01:25:56

Y ahí la configuras. 01:25:58

porque así al cargar los niveles 01:25:59

en el start de cada nivel 01:26:02

si metes operaciones 01:26:04

puedes dar nuevas operaciones 01:26:06

porque si no, digamos que dentro de un mismo nivel 01:26:08

tienes como dos 01:26:10

menús distintos y se te pueden 01:26:12

ir liando, lo bueno de que 01:26:14

se conectan los dos es 01:26:16

que tiene su 01:26:18

start y se eliminan cosas que no quieres 01:26:20

y se crean, es más sencillo 01:26:22

que ojo, lo que tú has hecho por ejemplo 01:26:23

se podría hacer durante la ejecución 01:26:26

el juego, mientras se está con la pelota 01:26:28

cuando le das al escape por ejemplo 01:26:30

el pause y se sobrepone un canvas 01:26:32

y ahí se podría poner 01:26:34

pero hay un método 01:26:36

¿el qué? 01:26:37

hay un método especial para eso creo, según he leído 01:26:39

los apuntes, no, no, sería mostrar un canvas 01:26:42

pero aparte lo que se hace es 01:26:44

parar el tiempo de ejecución 01:26:46

se pone el time.time 01:26:47

que es a qué velocidad y se pone en cero 01:26:50

y digamos que el juego se queda suspendido 01:26:52

y luego tú enseñas ese canvas 01:26:53

y tú clicas y cuando vuelves al 01:26:55

juego, pues el time.time 01:26:58

es el time scale, se vuelve 01:27:00

uno otra vez. Entonces entiendo 01:27:02

que tengo que hacer una escena nueva, me cargo este 01:27:04

canvas que acabo de hacer, hago una escena nueva, le meto 01:27:06

un canvas y ya lo... 01:27:08

Eso es, y hacer 01:27:09

los elementos de ese canvas nuevo. 01:27:11

Una cosa que no he dicho y es importante y además esto 01:27:14

creo que no lo ponen los apuntes. 01:27:16

Compárteme otra vez el Unity, porfa. 01:27:18

Un momentito. 01:27:20

Ahí lo tengo. 01:27:21

Cuando juegas, dale a 01:27:24

reproducir el juego. 01:27:26

vale 01:27:26

¿ves eso de dejar de compartir? 01:27:30

¿no le des? 01:27:34

¿está compartiendo? 01:27:35

a la derecha hay un minimizar 01:27:37

dale a eso para que se quite eso 01:27:40

espera un momento voy a bajar el volumen 01:27:41

vale 01:27:44

tú tienes una música que yo no llego a oír 01:27:45

pero porque no estás compartiendo 01:27:49

el sonido pero el audio source 01:27:51

desactívalo 01:27:53

el game object a la izquierda 01:27:54

al penúltimo 01:27:57

Ahí, venga, dale 01:27:59

Y minimiza lo que te había dicho antes, porfa 01:28:05

Ahí, vale 01:28:08

Esto ya lo vimos el otro día 01:28:13

Espera, no de esa nada 01:28:15

Si es del panel de game 01:28:16

Para testear bien las cosas 01:28:18

Tú ahora mismo estás jugando 01:28:20

O estás reproduciendo el juego 01:28:22

Con unas medidas 01:28:24

Digamos adaptables a la pantalla 01:28:25

que tienes de game 01:28:29

es decir, si arrastras tú el game y lo haces más grande 01:28:31

se hace más grande 01:28:33

nosotros lo que queremos es simular, por ejemplo en este caso 01:28:34

el 16 novenos de los móviles 01:28:37

es como una referencia 01:28:42

entonces, lo primero 01:28:44

y esto ya lo vimos el otro día 01:28:46

donde pone scale encima 01:28:47

debería estar a 1 siempre 01:28:49

ves que pone scale 1.1 01:28:51

eso es para ampliar 01:28:54

y ver de cerca 01:28:55

detalles 01:28:58

Pero el 1x este es el nivel de reproducción del juego 01:28:59

Y luego donde pone a la izquierda Free Aspect 01:29:03

Esto, ¿vale? Dale a ese desplegable 01:29:05

¿Vale? Ahora mismo se está adaptando a la pantalla 01:29:08

Pero deberías poner las dimensiones que te interesen 01:29:11

¿Ves que hay algunas? Como esa que pone Full HD 01:29:14

Que te da unos píxeles concretos 01:29:16

¿Vale? Pero normalmente, si por ejemplo es para móvil 01:29:18

O para cualquier tipo de pantalla 16 novenosa paisada 01:29:21

Si lo pones ahí, selecciónalo 01:29:24

vale, te lo pone 01:29:25

de esa medida referente a ese 01:29:29

tamaño, ¿qué significa eso? 01:29:31

que ahora mismo 01:29:33

a ver, amplíe y desamplía 01:29:34

este panel, no, no 01:29:36

en escala no, vete a 01:29:39

a game, vale, el menú game 01:29:41

vete abajo y arrastra hacia abajo 01:29:43

por ejemplo, haz más grande la ventana de game 01:29:45

no, bueno 01:29:47

te voy a compartir yo, vale 01:29:50

que creo que va a ser más sencillo 01:29:51

Ah, tú decías que arrastrar la ventana de game 01:29:54

Vale, si quieres la arrastro 01:30:04

Que la haga más grande 01:30:05

Lo que sea la idea 01:30:08

Hazla más grande, arrastra 01:30:09

Se irá adaptando 01:30:15

Al tamaño de ese juego 01:30:17

Muevelo hacia la derecha 01:30:19

Ahora lo tienes a 16 décimos 01:30:21

Dale a 16 novenos 01:30:24

entonces para verlo con la medida que es 01:30:25

porque si no te lo adapta más 01:30:28

eso es lo importante 01:30:30

que tenga la proporción que va a tener 01:30:31

porque si no igual te está metiendo más o menos fondo 01:30:34

vale 01:30:36

entonces eso es importante 01:30:36

tenerlo en cuenta 01:30:40

sobre todo ahora que estamos jugando 01:30:41

está mirando que 01:30:43

casi todos son en 16 novenos me parece 01:30:46

sí, sí, sí 01:30:48

las pantallas de móvil normalmente 01:30:49

la verdad que ahora están 01:30:52

que si el desplegable, que son como dos 01:30:54

y tal, pero los monitores 01:30:56

los móviles y tal 01:30:58

la referencia normalmente es 16 novenos 01:30:59

entonces, ahora que sí que 01:31:02

tenemos que ir viendo cómo queda el juego 01:31:04

pues lo suyo es poner un aspecto y aparecer 01:31:05

de proporciones 01:31:08

adecuadas, vaya, ¿vale? 01:31:09

Muy bien. Pues nada 01:31:12

muchas gracias, y lo del audio sur se ve 01:31:13

en el último tema, ¿vale? Todavía no 01:31:15

todavía no... De todas maneras no lo voy a quitar 01:31:17

que me gusta la música, lo dejo ya puesto 01:31:20

Ya eso, lo que tú veas 01:31:22

Muchas gracias por todo 01:31:23

Nada, gracias a ti por asistir 01:31:25

Un saludo 01:31:28

Tutoría 8 - DEIM - UT4 - Curso 23·24 - 7 Marzo - Contenido educativo

Del mismo autor…

Aula virtual (introducción)

BAILE NAVIDAD 6

Usar código en Arduíno

Registro en Wokwi y Tinkercad

Registro en Wokwi y Tinkercad

Elegir proveedor

Herramienta digital