Tutoría 8 - DEIM - UT4 y 5 - Curso 24·25 - 25 Febrero

¿Cómo estamos? Voy a compartir pantalla, a ver si veis mi Unity. ¿Estáis viendo mi pantalla un Unity? Sí. Vale. Pues nada, ya lo fui poniendo, no hay ninguna duda en el foro de este tema. Bueno, ni de ninguno pendiente. 00:00:01

por tanto entiendo que no hay 00:00:24

muchas dudas con el tema 00:00:27

la compañera me ha indicado 00:00:28

que sí que tendrá alguna consulta 00:00:31

así que a menos que me digáis 00:00:34

lo contrario vamos a ir con estas consultas 00:00:35

luego yo diré algunos 00:00:37

aspectos que me parecen relevantes 00:00:38

pero bueno, simplemente recordar que las tutorías 00:00:41

sobre todo son para resolver dudas 00:00:43

que el contenido en sí ya está en 00:00:45

el temario 00:00:47

entonces pues si te parece 00:00:48

bueno, eso 00:00:52

Una compañera ha indicado que estaba con la tarea y había algo como que le faltaba por saber, pues planteame la duda y vemos a ver cómo lo abordamos. Vale, me indica por el chat. Lo que no he podido hacer fue lo que pongo en el input, me salga en otra escena. Vale, te refieres a un campo de texto, ¿verdad? 00:00:53

Es decir, mira, de hecho creo que estáis viendo aquí mi pantalla 00:01:23

Para que lo entendamos todos, se os pedía una pantalla de inicio con las opciones de jugar 00:01:27

Otro botón que fuera el menú de configuración, que sería este 00:01:34

Y lo que está indicando la compañera, si no me equivoco y si no me corrige 00:01:37

Es que habíamos dicho que aquí se pudiera poner, por ejemplo, un nombre 00:01:41

Que cuando jugáramos se hubiera quedado guardado y que lo reflejara en el HUD en este caso 00:01:45

Básicamente, bueno, esto es lo de siempre 00:01:51

Son ejemplos de cosas que se pueden hacer 00:01:53

Lo importante, o lo que hay que extraer de esto es 00:01:55

Como bien ha enfocado la compañera 00:01:58

Que es que ese input se guarde 00:01:59

El contenido de ese input 00:02:01

Y se guarde de alguna forma para que entre escenas 00:02:02

Se almacene esa información y se vea 00:02:05

No sé, claro 00:02:08

Aquí ya es a veces un poco complejo 00:02:09

Dar la respuesta directamente 00:02:11

Porque puedes haber llegado 00:02:13

Hasta el punto del input de alguna u otra forma 00:02:15

Te voy a decir, por ejemplo 00:02:17

La forma en la que está hecha aquí 00:02:19

Y si te sirve, tú crees, pues ya estaría resuelto la duda, pero vamos a ir indagando un poco también cómo está configurada. Voy a hacer un repasillo, ya si también sirve un poco para los que a lo mejor están empezando la tarea, un poco para ubicar cómo lo he hecho yo, lo ponemos en común con a lo mejor con lo tuyo y vemos si esta respuesta, digamos, cómo está hecho aquí, te sirve, ¿vale? Si os parece. 00:02:20

Entonces, bueno, lo que se indicaba. Bueno, se ha metido una compañera, por también gestionarlo, no sé si has empezado ya con la tarea, si tienes alguna duda así concreta, por si, como ahora me voy a empezar un poco a arrancar a hablar de ciertas cosas, pues también, si hay una duda de algo específico, pues voy hacia eso. 00:02:45

Duda con los parámetros del slider. Vale. Vale, mira, por ir más al grano, hay dos menús, bueno, hay que hacer tres, incluimos el HUD, ¿no? Pero sobre todo vamos a ir uno a uno. Primero habría que hacer este que se indica que es, en este caso, el menú inicial, ¿no? Que es una imagen, ¿vale? Con tres botones. 00:03:10

Entiendo, por si no indagar más, que lo que es conectar, y además esto es algo que ya se ha adelantado un poco en la tarea 3, 00:03:34

conectar cada botón con que cargue otra escena, eso lo tenemos más o menos controlado. 00:03:42

Voy a hacer aún así un repaso muy rápido, ¿vale? 00:03:49

Pero, importantísimo, cuando vayamos teniendo niveles, que no sea solo un juego en el que hay un solo nivel, 00:03:51

sino que vamos a tener que ir conectando y cargando distintos niveles, 00:03:58

Bueno, incluso aunque sea uno, esto también hay que hacerlo, pero sobre todo si hay que conectar niveles, hay que siempre recurrir a este, que ya veremos sobre todo en el último tema, porque es desde donde se compila el juego, tenemos que recurrir a este File, Build Settings, el Build es el compilado, la construcción del juego, y aquí habrá que ir metiendo los niveles en un orden específico. 00:04:01

Además, no tiene por qué ser un orden específico, pero sí que es lógico porque lo que sí nos va a proporcionar este conjunto de niveles que vayamos arrastrando aquí serán estos números de índice, que son muy útiles para decir, oye, ojo, cuando des a este botón quiero que cargue la arcena de índice 1, ¿vale? 00:04:26

Entonces, bueno, eso es esencial y que en el juego ya haya una, bueno, pues gestión de estos niveles a nivel de orden y de tener conciencia de cómo se van, bueno, pues poniendo en serie estos índices. 00:04:46

Aquí ya veremos, bueno, como veis, hay distintas plataformas para exportar. Lo veremos en el último tema, pero esta ventana, muy importante, sobre todo en la fase final del juego. Pero vemos que ya incluso para ir relacionando niveles es algo que hay que ir haciendo. 00:05:02

Bueno, básicamente otra cosa, otro truco importante es que, como habréis visto en el tema, siempre que vayamos incorporando elementos de User Interface, se va a generar este canvas. 00:05:18

Y este canvas, al final, lo que suele ir haciendo es agrupar, y se ve en la pantalla de escena cuando seleccionáis el canvas, genera este rectangulillo blanco, que según como esté configurada, con las opciones del canvas scalar, del canvas en general, el render mode, vienen descritos en el tema también. 00:05:30

Ahora, si acaso volvemos a esto, pero dentro de este canvas es donde vamos a ir incorporando los distintos elementos de nuestras interfaces. Para que se vea el elemento de user interface en un nivel, siempre tiene que haber un canvas mínimo, puede haber más de uno que vaya agrupando distintas interfaces. 00:05:52

sí que es lógico lo más 00:06:15

o lo mejor realmente usar solo uno 00:06:17

que agrupe todo ¿vale? porque así 00:06:20

pues todos los elementos se escalarán 00:06:21

siguiendo una misma lógica, un mismo criterio 00:06:24

que si hacemos varios ya puede 00:06:26

haber ciertos conflictos y también 00:06:28

tiene que haber otro elemento que es este 00:06:30

que también lo genera automáticamente cuando incorporamos 00:06:31

un elemento de UI 00:06:34

en el nivel ¿vale? en la escena 00:06:35

este event system que básicamente sirve para 00:06:37

indicar así rápido 00:06:40

indicar si estamos 00:06:42

jugando con un teclado, ¿no? ¿Cuál es el elemento? Que sale seleccionado ya por defecto 00:06:44

y también para indicar las teclas de navegación, ¿vale? Si notemos con un ratón es muy fácil 00:06:51

decir aquí y aquí, ¿vale? Pero si jugamos con un gamepad o con otro tipo de dispositivo 00:06:56

que no es tan versátil, tan apuntable, no sé si existe esa palabra, pero espero que 00:07:03

me entendáis, pues hay que decir qué teclas, ¿vale? Y veis que ahora yo estoy dando a 00:07:09

flecha arriba y abajo del de mi teclado y veis que voy pasando entre un nivel y otro y esto se 00:07:13

debe a que está configurado en este input módulo vale si estáis usando el nuevo input system hay 00:07:19

que cargar otro se carga por defecto te da una sugerencia de carga de otra forma de indicar 00:07:24

que inputs o que axis vale o que botones o que elemento es el que proporciona cada acción pero 00:07:30

bueno el event system tiene que estar ahí incluso aunque luego lo dejáramos vacío en gran parte es 00:07:36

es un elemento que tiene que estar. Luego, ya dentro del canvas, como también se explica en el tema y supongo que es una de las cosas que estaréis tocando en esta tarea, 00:07:41

dado que se piden, se pueden ir metiendo desde imágenes hasta botones, campos de texto, sliders, etc. 00:07:52

Bueno, distintos elementos están referidos a esta gestión de los elementos de User Interface. 00:08:01

El Canvas yo también pienso, y suele ser creo un buen enfoque, que cuando tengo muchos elementos dentro y tengo que ir gestionando código para hacer referencia a algo de estos botones o estos inputs o imágenes, 00:08:13

es el mejor sitio donde poner el script que yo cree, el que sea, para gestionar los distintos elementos. 00:08:29

¿Por qué? Porque habréis visto, por ejemplo, los botones que tienen una forma simplificada o rápida de llamar a métodos 00:08:41

y que por tanto se ejecute por código, se ejecuten acciones, que es que dependiendo de qué tipo de elemento de user interface, 00:08:50

abajo pueden tener ya lo que se conocen como eventos, que digamos que ya hay una configuración hecha en Unity en ese elemento, que dice, oye, pues en este elemento botón, como es lógico, un botón por definición es botón porque sirve para pulsar un botón y que ocurra algo, ya hay un evento, digamos, que está siempre escuchando que ocurra algo en relación, en este caso, a que se haga clic. 00:08:58

Es decir, que cuando se haga clic en este elemento, por ejemplo, en este botón de play, es el que está aquí ahora mismo seleccionado, lo he colocado y al final lo que se puede hacer aquí es cargar un script que tengamos y llamar al método que tengamos previsto. 00:09:23

¿No? Entonces, al final, la forma de no perderse cuando cargamos este script, que dentro tiene un método, ¿vale? Voy a abrir ese script para que veáis también qué script es, para que no sea tan abstracto, ¿vale? 00:09:39

Es, yo tengo en el primer, en el menú de introducción este que hay, realmente lo único que hay que hacer es poner botones y que esos botones, al pulsarlos, nos lleven a distintas escenas. 00:09:54

No hay comportamientos más complejos en este, en el otro menú sí los hay y por eso probablemente es porque estáis más atascados en ese nivel, pero bueno, simplemente tener en cuenta, pues yo entonces he dicho, vale, este canvas voy a ponerle un script ya puesto aquí que se llama loader scenes, que sirve para cargar escenas y lo tengo aquí preparado con su namespace, su librería para la gestión de niveles, ¿vale? 00:10:06

esto también lo explica el tema, que esté preparado con métodos públicos, dos métodos públicos que veis que no se llaman en ningún tiempo de ejecución, 00:10:33

sino que, es decir, yo podría hasta borrar esto, y he hecho métodos públicos solo con el propósito de luego arrastrarlo a estas acciones que ya están configuradas 00:10:43

en un elemento de UI, en este caso botones para clicar. Entonces yo en el canvas, que es un GameObject que puedo arrastrar aquí, 00:10:52

cuando lo arrastre, lo que va a hacer es detectar ese script que tenemos aquí. Yo arrastro este canvas y luego del listado de opciones que tenemos aquí, 00:10:59

nos van a salir que al hacer clic, no solo podemos acceder a ese script que tiene este objeto que se llama load the scenes y que aquí, por ejemplo, 00:11:11

tendrá, por ejemplo, este método salir, que es uno que he creado aquí, pues con ese nombre, ¿vale? Y otro será loadScene, que es el que he creado yo aquí, ¿vale? 00:11:20

Recuerdo que tienen que ser públicos. Pues yo tengo aquí métodos ya que vienen por defecto, pero también métodos que he creado yo y que aquí, si está bien configurado, 00:11:32

la gracia que tiene también es que podemos poner un parámetro al configurarlo, que es este parámetro que aparece aquí. Entonces, gracias a esto, lo que podemos hacer es 00:11:41

decirle, vale, yo voy a decir que cuando hagamos clic cargue el script de load the scenes porque está configurado, está ya digamos establecido como componente en este canvas, pero aparte yo, claro, cuando pulso el botón no es solo carga escena, quiero que sea versátil y no hacer un método como pasaba, lógicamente también, esto no es ninguna crítica, 00:11:50

Como pasaba mucho en la tarea 3, que hacíais un script para cargar cada nivel. Script para nivel 2, que lo que hacía era cargar el 3, y script para el 3, para cargar el 4. En el tema se habla de que las escenas se pueden cargar poniendo un número, que es el número del índice que acabamos de hablar en el build settings, o también más complejo de adivinar, que es poner el nombre, por ejemplo, de esa escena. 00:12:18

Pero los números, lo bueno que tiene es que se puede sumar, restar y se pueden hacer operaciones para navegar entre unos y otros. Por tanto, aquí, si yo, digamos, que preparo este parámetro en el propio método, luego ya voy a poder cargar la escena de este número que pongamos en el inspector, ¿vale? 00:12:45

Aquí no recuerdo, la escena que quiero cargar es el nivel 1, ¿vale? Aquí tendré que poner, a ver, que es que como lo he tocado no me acuerdo, nivel 1 es el index 1, perfecto, pues 1, ¿vale? Entonces yo he configurado que cuando haga clic en ese botón, aquí lo tengo, paso al nivel 1 que es el de jugar y ya puedo jugar, ¿vale? 00:13:05

Voy a ver si me estáis escribiendo por ahí, que yo entiendo que no, vale, que no he visto nada, vale, entonces es importante tener en cuenta que los comportamientos de los métodos interactivos, y voy rápidamente, no lo quiero guardar, vale, que es lo que he cambiado por si había tocado algo, pero en un input, vale, por ejemplo, que es esta entrada de texto, si vamos navegando por sus elementos y vamos a input username va a haber otros, 00:13:26

Este es otro de los elementos que se pueden agregar. Este, por ejemplo, o el legacy, el input field. Es ese campo de texto que se puede introducir. Aquí no es al hacer clic cuando sucede la acción. 00:13:54

Aquí es cuando cada vez que vayamos cambiando un valor, es decir, vayamos tocando una tecla, pues yo aquí he preparado otro canvas con otro script diferente adaptado a qué estamos buscando en este menú, 00:14:08

pues que se va a ocupar de un texto, de un slider y también de los textos que va a ir mostrando aquí de dificultad. 00:14:22

Bueno, ahora vamos a ese, pero simplemente que veáis que en el canvas de este nivel lo que he hecho es un menú, un script, perdonad, pues ya preparando todas las necesidades que vamos a tener con estos inputs y los eventos que tienen aquí. 00:14:29

Los textos, estos input fields, no solo pueden lanzar eventos cuando estamos cambiando los valores. Puede ser que sea cuando terminemos de editar y salgamos. En ese caso, habría que añadir aquí el canvas, en este caso, que es el objeto que tiene el método, y aquí poner el método que nos interesaba. 00:14:43

DateDestines, este canvas, sería el de ConfigMenu, ¿vale? Pues yo busco aquí que he preparado funciones en ConfigMenu y aquí tendré que ver, pues por ejemplo, UpdateInput y UpdateSlider, que son los métodos públicos, ¿vale? 00:15:08

Que he generado yo en este, y os lo voy a enseñar para que lo veáis también. A ver si quiere, que es configMenu, que es otro script que yo he creado aquí, pues que tiene otros métodos públicos, que nuevamente lo que haces es, al lanzarse ese evento, pues hará lo que haga aquí. 00:15:26

El de updateSlider será este y el de updateInput será este. Nuevamente, que sean métodos públicos. 00:15:45

Entonces, voy a eliminar esto. Simplemente eso, que tengáis en cuenta que el canvas es muy buen elemento para ir. 00:15:57

Aquí había un botón que queremos que cargue escenas. Puedo hasta aprovechar el mismo porque luego al dar a este botón, 00:16:04

lo que pondré es que vaya al arcenacero, porque estoy reutilizando scripts, no hay que hacer uno por cada uno, porque gracias a ese parámetro en el método puedo indicar a qué índice de los build settings quiero dirigirme, quiero que se cargue cuando dé ese botón, pero eso. 00:16:11

Luego he añadido otro script en el canvas que tiene aquí distintas funcionalidades, distintas variables con las que iremos jugando. 00:16:26

A ver hasta aquí, ¿qué tal? ¿Me seguís? Entiendo que los que habéis ya empezado a trastear con la tarea, hasta aquí más o menos entendido. 00:16:38

Ya el problema es escribir los códigos para ir consiguiendo lo que nos interesa. 00:16:48

si tenéis alguna duda hasta aquí 00:16:53

decidme 00:16:56

mientras escribís o me decís 00:16:56

simplemente algo 00:17:01

que es importante 00:17:03

que también cuando os hayáis puesto 00:17:05

no quiero guardar 00:17:08

cuando os hayáis puesto a trastear 00:17:09

con crear el canvas, poner la imagen de fondo 00:17:11

etcétera 00:17:13

es que a veces 00:17:14

no es del todo intuitivo 00:17:16

cómo surge esto 00:17:18

en el canvas, en cualquiera 00:17:20

al final está, cómo se ve este canvas 00:17:21

Pues si es una sobreposición a lo que haya en la escena, ¿no? Que sea un poco independiente de la cámara y que básicamente se ponga por encima, que se ubique en el espacio un elemento 3D o que tenga en cuenta una cámara y ya el plano focal también, ¿vale? 00:17:24

Pero más que eso, que bueno, si tenéis duda lo vemos también, es este canvas scaler en relación con que en la pantalla game, ¿vale? Y esta es la forma de testear si están escalándose bien o no los elementos que tengamos en juego de user interface, ¿vale? 00:17:37

Es que nosotros, por defecto, en la pantalla de juego, en donde estamos simulando el juego, ¿vale? Vais a ver que aquí hay distintos aspect ratios. Esto, si no me equivoco, venía introducido un poco en el tema 1, en la UT1, si no me equivoco. 00:17:57

Pero nosotros aquí podemos definir cuál es el tamaño de ese juego, el tamaño final en el que estamos pensando que se está haciendo nuestro juego. 00:18:13

Vosotros tened en cuenta, y por eso sucede que yo cuando voy arrastrando, haciendo más grande y más pequeña esta pantalla, salen estos rebordes que son el fondo, este Skybox, este HDR que envuelve. 00:18:22

pero nosotros cuando juguemos 00:18:38

no vamos a querer que se vean esos fondos 00:18:41

queremos que se adapte a las medidas 00:18:43

si nosotros sabemos que nuestro juego se va a reproducir 00:18:46

en dispositivos que son de 1920x1080 píxeles 00:18:50

o Full HD 00:18:54

nosotros podemos definirlo ahí 00:18:55

pero tener en cuenta una cosa 00:18:56

y esto es algo que a veces no tenemos en cuenta 00:18:59

pero cuando hablamos de un píxel 00:19:02

realmente un píxel es un cuadrado con información de brillo 00:19:04

un píxel de una pantalla, pero no tiene una medida establecida. 00:19:08

Habrá móviles, de hecho normalmente los móviles con los que contamos 00:19:12

son una pantalla pequeñita de 1920x1080, si lo ponemos en horizontal, 00:19:16

y es la misma resolución, las mismas dimensiones en píxeles 00:19:22

que a lo mejor el monitor de ordenador, que es 5 veces más grande, 00:19:26

que también es 1920x1080 píxeles. 00:19:29

Por eso es importante tener en cuenta que se pueden hacer contenidos 00:19:33

de user interface, con un tamaño de píxel lo que se llama constante, 00:19:37

que es decir, en relación a las dimensiones que tenga la pantalla que sea, 00:19:43

que cada unidad de medida que tenga nuestro proyecto, que sean 100 píxeles. 00:19:49

Entonces están, y luego aquí hay una que incluso lo que hacemos es que decimos, 00:20:02

No, la pantalla es que va a tener estas medidas físicas, reales y con una densidad de píxel X, que es esto del DPI. ¿Qué sucede con esto? Que hay siempre que tener en cuenta que a menos que sepamos las medidas concretas de la pantalla y siempre vaya a ser la misma o tenga muy claro que siempre va a ser en un dispositivo de 1920x1080 en este caso, habría que jugar o lo suyo sería que se escalara con el tamaño de la pantalla. 00:20:06

Es decir, que nosotros pongamos una referencia concreta y por eso se pone esta resolución de referencia en plan, mira, el trabajo que estoy haciendo ahora es en base a estas medidas. Pero bueno, que si luego se empieza a hacer más grande o más pequeño, y esto lo hago en la pantalla de game, no en la de escena. 00:20:34

La escena es el editor de Unity, vamos, es como donde operamos, donde se ve el resultado es en el simulador de juego. 00:20:52

Y aquí es donde podemos decir, vale, que no sean unas medidas concretas, que no sean 1920 píxeles por 1080 píxeles que el dispositivo le está diciendo que tiene estas dimensiones, 00:21:00

sino que tenga un aspect ratio, vale, un alto y un ancho siempre de 1920 por 1080. 00:21:10

Sí que es verdad que a no ser que sean pantallas muy extrañas, está un poco universalizado este 1690, o bueno, en informática sobre todo un 1690, perdón, está especializado, está estandarizado. 00:21:14

Pero esto a lo que quiero llegar es que se habla luego en los elementos, en los propios elementos, de que existe esto de los puntos de anclaje y esto tiene sentido cuando ponemos unas dimensiones que están establecidas. 00:21:29

Si lo que hacemos es que se escale con el tamaño de la pantalla, veis que lo que va a hacer es, oye, tómate esta proporción de aspecto, este aspect ratio de 16 novenos y si la pantalla fuera más grande o más pequeña, mientras tenga esa proporción, pues no va a haber problema porque se escalará todo uniformemente. 00:21:46

¿Qué ocurre? Que si tenemos una pantalla muy pequeña también puede suceder que de pronto los botones se hacen muy pequeños y si queremos que aunque la pantalla, la resolución fuera pequeña, los botones como los vamos a tener que pulsar se hicieran más grandes, ahí es cuando nos puede venir bien jugar con que lo que tomes en relación a los píxeles que tenga esa pantalla, pues oye, yo quiero que este elemento, y aquí es donde se irán ajustando la proporción de cuántos píxeles tiene cada pantalla, 00:22:07

Bueno, esto me está saliendo, bueno, lo voy a poner un poquito más grande, ¿vale? 00:22:37

Es donde yo indico cómo quiero que esto se escale o no, ¿vale? 00:22:41

Que es donde habrá que ir diciéndole que esto tenga una proporción X 00:22:45

y este botón, por ejemplo, de jugar, que lo vemos aquí con estas anclas, 00:22:51

se vaya escalando a medida que esa pantalla detecte que es más grande o no, ¿vale? 00:22:58

Esto ya, a ver, lo voy a hacer con el botón de jugar. 00:23:02

Pues si vamos definiendo aquí estos puntos de anclaje, cuando vayamos haciendo más grande y más pequeña la pantalla, veis que sí que se queda en un sitio y con unas proporciones. 00:23:05

A lo que quiero llegar, que esto sí que es un poco prueba y error, porque de momento es un poco confuso entenderlo claramente, en plan cuando sucede algo, cuando sucede no, es que a no ser que tengamos muy claro que va a tener unas medidas muy concretas, normalmente lo que nos interesa es que toda la pantalla se haga más o menos grande. 00:23:16

Porque además, por lo general, eso, tenemos ya proporciones muy estandarizadas. Pero otro elemento importante que a veces sucede también cuando corrijo vuestras tareas, también normal, es que cuando ponemos FreeASPT, básicamente que nos llene con contenido todo el cuadro que tengamos, todo el visor que tengamos de la pantalla game. 00:23:34

Nada se adapta. Se adapta al ancho y al alto para que se ajuste en relación a lo que sería ese 16 novenos, en este caso, que está ahí establecido. 00:23:54

Y de hecho, si os fijáis, por eso sale esta caja que sobresale, porque al final se está todo el rato ajustando para que coja o el ancho o, atención, el alto. 00:24:06

Y veis que ahora coge la otra dimensión de esta caja de referencia para que se adapte en todo momento. 00:24:17

Pero lo suyo, y aquí siempre está todo a escala 1, lo suyo en ocasiones cuando queremos ver que algo tiene unas medidas concretas y cómo se va a ver realmente es que si nosotros tenemos una pantalla en la que estamos haciendo las pruebas, que es 1920x1080, lo pongamos ya en esas dimensiones y veréis que ahí en ese caso sí que la escala va cambiando, se va haciendo más grande o más pequeña. 00:24:23

porque aquí con respecto a mi monitor 00:24:47

sí que se está viendo pequeño 00:24:50

mi monitor podría enseñarlo 00:24:52

en ese aspecto que tenemos 00:24:53

y dado que mi monitor le está diciendo al sistema 00:24:55

que es 1920 píxeles 00:24:57

por 1080 00:24:59

en realidad aquí sabe que se está haciendo más pequeño 00:25:00

pero en realidad esto como se vería 00:25:04

si lo viéramos a tamaño completo 00:25:06

es esto, esta es la medida real 00:25:07

que va a tener en un dispositivo 00:25:09

con el que estoy viendo 00:25:12

entonces que a veces pueden surgir 00:25:12

Podría surgir como pixelados raros o no. Esto para comprobar que se ve sin pixelado, porque a lo mejor estoy haciendo, ahora no porque estoy haciendo que sean las dimensiones, pero veis que se están pixelando aquí, imagino que lo veis en el streaming, se están pixelando aquí elementos porque estoy haciendo una escala sobre el visor, pero realmente las dimensiones es esta. 00:25:15

Y esta es la referencia que tendríais que tener de si se está viendo algo pixelado o no, ¿vale? Que a veces sucede que escaláis los textos y se ven pixelados, o no, o a veces es porque estáis haciendo esto y lo estáis viendo así, ¿vale? Que sepáis que la referencia de cómo se ve es siempre 1. 00:25:36

Bueno, es verdad que para verlo bien, pues lo suyo sería que cuando reproduzcamos, al darle a play, pongamos este modo de play maximize y va a coger el tamaño o casi, aunque aquí ponga escala 1, realmente no está a escala 1 porque esto está ocupando espacio, pero veis aquí que tiene las dimensiones más o menos que debería tener. 00:25:52

Se está ajustando a todo el ancho de la pantalla. Entonces, bueno, es como mejor se vería para verlo lo más fiable posible. Dicho esto, bueno, lo mismo de siempre. En realidad, si ponéis un 16 novenos, pues más o menos vais viendo las medidas. 00:26:15

Pero no se está diciendo cuándo está viendo ese pixelado o no por esta ampliación, porque siempre te va a poner uno. Aunque yo lo haga muy pequeño, veis que como es relativo el espacio y no está cogiendo el dispositivo en el que lo vemos, que en este caso es mi pantalla o puede ser el móvil, pues se ve así. Siempre a un uno que no es el real, no es el tamaño real. 00:26:30

Pero bueno, está haciendo una adaptación con este Scale with Screen Size 00:26:51

Que sí, que en realidad es relativo 00:26:55

Pero bueno, que sepáis que eso, que si estáis trabajando para pantallas concretas 00:26:58

O dimensiones de píxel concretas, esto es muy importante 00:27:01

Vale, hasta aquí, ¿qué tal? 00:27:05

Y ya paso un poco a hablar de la otra chicha, que son las dudas 00:27:06

De hecho, que han traído algunas compañeras 00:27:11

Vale, me ponen una pregunta 00:27:13

Algunas fuentes que he cargado en Unity no me funcionan 00:27:19

Aparecen, pero no se aplican, es muy raro 00:27:22

Vale, necesito que me contestes si estás usando en tu proyecto el TextMeshPro o el TextLegacy. Es decir, si has instalado el TextMeshPro. Vale, el TextMeshPro. Si no me equivoco, lo voy a buscar un segundo, os dejé un tutorial. Mira, aquí. 00:27:24

Si vas al apartado 3.1.1, hay aquí un método, imagino que es esto, de cómo convertir una fuente de texto, una tipografía, ¿vale? Para que funcione en TestMeshPro. 00:27:41

Si no me equivoco, ¿vale? Porque tendría que verlo, pero si no me equivoco, cuando instalas el TestMeshPro, yo ya lo he instalado, como pone en el tema, hay un menú aquí que se llama FontAssetCreator. 00:27:54

Bueno, pues mira, tendría que importar esto, que no lo hice. Lo importo, dame un segundo de cargue y tal, ¿vale? Bueno, y cuando, bueno, perdón, que se me ha desconfigurado un poco la pantalla. 00:28:09

¿Veis mi pantalla, verdad? 00:28:22

A lo mejor 00:28:30

Es que como ha recargado 00:28:31

El editor algo 00:28:32

Eso, cuando instaláis 00:28:34

Todo lo necesario para ir funcionando 00:28:37

Con TestMesh Pro 00:28:39

Aparece esta opción del 00:28:40

Asset Creator y aquí puedes 00:28:42

Buscar esa tipografía 00:28:44

Que tengas, la metes y bueno 00:28:46

Hay distintas opciones que en principio 00:28:48

no habría que tocar mucho porque yo creo que 00:28:50

por defecto lo va a hacer bien y es 00:28:52

generate font at last 00:28:53

cuando le das aquí hace un proceso 00:28:56

que básicamente lo que hace es guardar 00:28:58

esa tipografía 00:29:01

no sé muy bien donde me la guarda ahora mismo 00:29:01

pero básicamente 00:29:04

en algún punto del nivel 00:29:06

o igual hay que guardarlo 00:29:09

y ahora no me acuerdo 00:29:10

aquí en fonts, vale 00:29:11

me ha creado esta tipografía 00:29:13

¿vale? y esta tipografía ahora 00:29:16

sí que la puedo meter pues en 00:29:18

donde haya un campo de texto pues se puede meter este legacy vale y en principio bueno es que yo 00:29:20

no estoy usando el tema es pro vale ese es el problema que él cuando no estés mes pro con 00:29:29

arrastrar la tipografía a los assets vale ya se carga ya se puede usar pero tres meses pro como 00:29:35

tiene más opciones de sombrearla de ponerle rebordillos hacer ese tipo de cosas hay que 00:29:41

hacer esta operación de convertirla vale con el fondo a ser creator y ya una vez 00:29:46

está creado ya si la puedes usar en un test mes pro de hecho vamos a pongo una 00:29:50

aquí aunque sea de prueba voy a poner aquí y voy a decirle que sea liberation 00:29:56

sanz esta tipografía aquí le digo tipografía 00:30:02

aquí y ya me la está cogiendo por lo que veo 00:30:06

La que acabo de crear es esta, si no me equivoco, ¿vale? Y, bueno, lo que voy a hacer es poner hola y lo voy a poner más grande y que esté en donde tiene que estar, que es, epa, bueno, esto, la cosa es que está muy, vale, importante. 00:30:12

¿Por qué no se está viendo? Porque lo he creado fuera del Canva, ¿vale? Importante también, que si no, no se va a ver en la vida. Y... Espera, perdona, no se está viendo también. ¿Por qué? Bueno, vale, porque se está desbordando probablemente. 00:30:40

Está ahí 00:31:06

¿Por qué no se ve? 00:31:16

Vale, bueno, lo primero 00:31:18

Voy a borrar esto, voy a hacer el canvas 00:31:19

¿Cuál os recomiendo usar? 00:31:21

Está detrás del fondo 00:31:26

Ahora lo vemos, pero 00:31:27

No, pero no está detrás del fondo 00:31:30

Bueno, ahora lo probamos 00:31:32

Si lo dice será 00:31:34

Vale, ahora sí está 00:31:35

No sé, al crearlo no lo he creado bien 00:31:37

Ahí está, ¿vale? 00:31:39

Ahora sí que eso. 00:31:40

Importante, cuando creéis un elemento de UI, 00:31:42

si ya está el canvas, pues 00:31:44

dadle al canvas que os va a 00:31:45

quitar problemas. Sí, yo antes cuando lo arrastraba 00:31:48

en principio estaba ya 00:31:50

abajo del todo. Bueno, esto 00:31:52

lo que dice el compañero, el orden 00:31:53

de renderizado, cuando hay elementos 00:31:56

que ocupan todo como este fondo, 00:31:58

va de abajo a arriba, es decir, 00:32:00

lo de abajo se ve por encima. 00:32:02

Por ejemplo, 00:32:04

si yo quito aquí zoom 00:32:05

y pongo 00:32:08

voy a hacer más grande la caja 00:32:08

si lo pongo encima 00:32:12

imagino que lo veis 00:32:14

del botón, al estar por debajo 00:32:16

la jerarquía se ve por delante, si lo pongo 00:32:18

por detrás, se ve por detrás 00:32:20

¿vale? es lo que decía, pero yo creo que estaba bien 00:32:22

pero vaya, tipografía 00:32:24

¿qué usar? pues la que 00:32:26

queráis 00:32:28

la verdad es que no tengo 00:32:30

ninguna pensada 00:32:32

si queréis 00:32:33

esta de Legacy Runtime, si no me equivoco 00:32:35

viene con el propio sistema 00:32:38

entonces 00:32:40

pues esa misma 00:32:41

no recuerdo 00:32:43

si esta la descargué o 00:32:45

la bajé de por ahí, pero yo creo que esa está 00:32:48

ya directamente con Unity 00:32:50

pues esa por ejemplo podría 00:32:52

estar bien 00:32:54

pero la que 00:32:55

veáis, pues básicamente que se vea 00:32:58

bien, que sea 00:33:00

hombre, normalmente las 00:33:01

gordotas, las que son más 00:33:04

así más gruesas 00:33:06

que tienen así, y lo que se llama un comprés, que es que son más verticales a veces que horizontales, que es lo que pasa aquí, que son bastante verticales, pues funcionan bien. 00:33:07

No lo sé, si queréis tipografías hay una web que supongo que conocéis de RPMI que se llama, bueno, La Font, por supuesto, que tiene muchísimas, 00:33:17

no siempre tienen que ser de muchísima calidad, pero hay muchísimas y muchas gratis, os lo ponen aquí, en muchas categorías. 00:33:29

Luego hay otra que son como más de diseñadores establecidos, que es esta de Lost Type, que también tiene muchas tipografías y en algunos casos son gratuitas. Aquí, a ver, ¿cómo era para ver si vamos a fuentes? Pues, por ejemplo, esta, no todas son gratuitas, pero, por ejemplo, esta de Tofino, que además veis que tiene muchos gruesos. 00:33:36

pues aquí 00:33:57

si pone que es un paga lo que quieras 00:33:59

pues aunque no sea lo más 00:34:02

adecuado probablemente, si ponéis cero la podéis descartar 00:34:05

compañero dice, los assets de Unity hay algunas bonitas 00:34:08

también en Asset Store 00:34:11

pues también puede haber 00:34:12

aunque yo verdad que no suelo buscarlas 00:34:17

aquí, también hay a veces 00:34:20

fuentes que se pueden usar 00:34:23

Vale, entonces, bueno, pues la que veáis más adecuada 00:34:26

Esta de Runtime, a ver, yo creo que es que viene con el sistema al menos en Windows 00:34:30

Sí, es que de hecho es la que viene por defecto con Unity, si no me equivoco 00:34:37

Entonces, bueno, fíjate que es la que estoy usando yo en el ejemplo 00:34:45

No me preocupa de poner otra más compleja, ¿vale? 00:34:49

Entonces, ¿dudas que tengáis con respecto a este menú de inicio de los botones y poner la imagen, etcétera, a nivel de código, etcétera? O paso al otro, que es quizá el que a nivel código tiene más enjundia. 00:34:52

A ver, un segundín, que voy a ver si hay algo más que explicar aquí de lo que yo hice por código. Bueno, luego hablaremos de esto, que es que si carga la primera escena, yo he hecho que las vidas se recarguen con tres. 00:35:09

y uso este GameManager, ahora vemos, pero que básicamente es el script, lo tengo aquí, otro script que se llama GameManager, 00:35:23

que la gracia que tiene es que todo lo que tiene dentro son variables estáticas. 00:35:31

Y con variables estáticas, en cómo estamos funcionando en esta ocasión, es, y aquí soluciona parte de la duda que me están diciendo 00:35:35

de cómo cargar un test input que se pone en un menú para que salga en el hat del otro, 00:35:45

que es que habrá que guardarlo en una variable estática pública siempre, de tipo string, que es username. 00:35:52

Y en esta variable estática, que va almacenando independientemente de la escena, 00:35:59

digamos que está por un nivel superior al resto de scripts, a nivel de que siempre está accesible, 00:36:04

aquí es donde guardaremos este nombre. 00:36:11

De hecho ahora hablo del Game Manager 00:36:14

Si me decís que no tenéis 00:36:16

Dudas de este primero 00:36:18

Antes incluso que pasara el de configuración 00:36:21

Hacemos una 00:36:23

Una visita a esto 00:36:24

Esto, de este nivel 00:36:26

¿Alguna duda? 00:36:28

Paso a la siguiente 00:36:30

Vale, dudas, me dicen 00:36:31

Podéis hablar, eh, por micrófono 00:36:37

Si es más rápido, pero bueno 00:36:40

Os vemos si me lo escribís 00:36:42

O si no voy avanzando y luego vuelvo allá 00:36:43

Digo porque es que si no a lo mejor tardáis 00:36:45

Sí, hola 00:36:47

A ver, es una tontería 00:36:49

por ejemplo, con el ratón pasas por 00:36:51

jugar, configuración, salir 00:36:53

¿lo podemos también hacer 00:36:55

con teclado, ratón y mando? 00:36:57

¿Te refieres 00:37:01

a la navegación? 00:37:02

Sí, eso es por lo que existe 00:37:03

este Event System 00:37:05

y está el primero 00:37:06

que está seleccionado 00:37:10

que yo he puesto el botón play 00:37:11

para que aparezca y por eso 00:37:13

de hecho cuando yo doy a reproducir 00:37:15

vas a ver, yo no toco nada, bueno 00:37:17

está esto de maximizado, ves que jugar está 00:37:19

seleccionado, y yo ahora voy 00:37:21

a mover las flechas del ratón 00:37:23

de, uy, del ratón, las flechas 00:37:25

del teclado, no estoy tocando el ratón, puedo ir 00:37:27

hacia arriba, hacia abajo, y luego 00:37:29

le doy a intro, y juego, no he 00:37:31

tocado el ratón para nada, eso 00:37:33

se, y voy a quitar esto de 00:37:35

maximizar para que se vea todo 00:37:37

claro, tú con el event system dices 00:37:39

primero, cuál de los elementos 00:37:43

es el que aparece seleccionado 00:37:45

este button play, lo he arrastrado y lo he dejado ahí 00:37:47

y aquí están los ejes 00:37:50

que son los axis 00:37:52

se llaman igual que los axis 00:37:53

que ya conocemos, pero vamos a 00:37:55

conocerlos otra vez, de los 00:37:58

project settings y el input manager 00:38:00

¿vale? pues con las 00:38:02

teclas que tengamos aquí de horizontal 00:38:04

hará movimiento horizontal, vertical 00:38:06

submit, que es el de acceder 00:38:08

y el de cancelar, que es pues para 00:38:10

para no... si hay alguna 00:38:11

acción que se deshabilitar 00:38:14

una vez ya está hecha. Se hace con las teclas que pongamos aquí. Por ejemplo, el vertical, que es el de las flechas arriba y abajo, 00:38:16

también debería, y lo voy a hacer ahora mismo, con la S y la W navegar. Esto se da, creo que lo pone también en el tema, 00:38:24

cuando tenéis botones y tienen que ser elementos que se puedan seleccionar. Y básicamente serán los elementos que dentro de sus opciones 00:38:34

tengan esto de interactable, unos solos botones, si no me equivoco, luego lo vemos, en los input fields también habrá algo relacionado 00:38:44

con el interactable, los sliders también, ¿vale? Pero esto se define en esta navegación, esta es la automática, que lo que hace es ver 00:38:52

dónde hay distintos elementos interactuables en la escena, ¿vale? Y hace una navegación, digamos, automática, que cuando damos a este botón 00:39:01

de visualizar, ¿vale? y nuevamente hay que ir a la escena, no al juego 00:39:09

¿vale? veis que salen esas flechitas que pone arriba y abajo, porque ha detectado 00:39:13

que para pasar de este a este, pues lo lógico 00:39:17

es una dirección vertical, si yo por ejemplo moviera 00:39:21

esta flecha, veis que ya empieza a complicarse, dice, si está no jugar 00:39:24

doy a la, y ves que sale de la derecha, voy aquí a config 00:39:29

¿vale? y ahora, el primero que va a salir seleccionado es jugar 00:39:32

y para ir, es decir, si doy ahora abajo, si doy ahora abajo, espero que veáis la flecha porque igual lo veis muy pequeñillo, me acerco aquí, cuando yo dé, vuelvo a cargar que se ha salido, cuando yo dé abajo va a ir a salir ahora, ¿vale? 00:39:36

Y cuando de arriba va a config y cuando doy arriba o a la izquierda va a jugar. Esto se debe a que se está gestionando con esta navegación y con visualizar vemos, si activo o desactivo, esto es solo una ayuda visual de cuál es, por qué lado es la tecla de navegación para ir a otro de los elementos. 00:39:51

Eso lo hace en automático, como dice, de manera automática. Si lo pones en explicit, hay una forma de... a ver, espera, dejo el visualizar, quito todo y digo explícito. 00:40:10

Entonces aquí lo que habrá que ir poniendo, aunque esta opción no la recomiendo y tampoco tengo muy claro cómo funciona, si te digo la verdad, es que podemos ir arrastrando aquí, al darle abajo en este botón de play, quiero que vaya al botón de config. 00:40:23

Y cuando dé a la izquierda en este botón de play, porque cada uno tiene su propia navegación que habría que ir configurando, vas diciendo de manera explícita hacia dónde hay que dar, cuál es la dirección. 00:40:38

Pero bueno, lo suyo es poner que sea automático 00:40:53

Y si ponéis horizontal y vertical 00:40:57

Con esto podéis restringir que a lo mejor 00:41:00

Todas las interacciones tengan que ser de manera horizontal 00:41:02

Y no se admitan las verticales 00:41:06

Pero bueno, esto habría que irlo haciendo en todos los botones 00:41:09

Cada botón tendría sus combinaciones 00:41:11

Lo más fácil, el automático y detecta 00:41:14

Incluso quitar el explícito 00:41:16

Y aquí detecta según visualmente 00:41:17

Cómo se distribuyen los elementos de la escena 00:41:21

pues veis que va poniendo unos axis, unos botones que son de izquierda a derecha, arriba, abajo, los que van haciendo la navegación, ¿vale? Entiendo que te contesta la duda. 00:41:22

Sí, gracias. 00:41:36

Yo no he conseguido ponerlo también con el teclado, solo me funciona con el ratón. 00:41:38

Sí que es verdad que hay una cosa un poco pejiguera, que es que cuando detecta que ya hay un ratón y clicamos con el ratón, ya digamos que la navegación por teclado no funciona, ¿vale? 00:41:41

Porque ya detecta que hay otra forma de operar más directa, ¿vale? 00:42:00

Por eso, cuando yo arranco el juego, aparece en estas selecciones y puedo ir para arriba o abajo, 00:42:06

pero ya en cuanto me meto y, bueno, si clico evidentemente, 00:42:11

pero ya cuando a veces me pongo encima y clico fuera, dice, ah, vale, que hay un ratón y ya como que se relaja. 00:42:15

No sé forzar para que sí, bueno, es que es eso, es que entiende que cuando ya usas el ratón, 00:42:24

pues vas a usar el ratón y no el teclado 00:42:29

y eso lo, digamos, lo discrimina 00:42:32

al arrancar el juego y si ya ve 00:42:34

que tiene un ratón, pues pasa al modo ratón 00:42:36

¿vale? pero en teoría es así como se 00:42:38

como se define todo esto 00:42:40

¿vale? 00:42:42

vale, pues 00:42:49

vamos, vale, voy a explicar 00:42:50

qué es el Game Manager, hay una 00:42:52

cosa que pone en el tema, que es verdad que en esta versión 00:42:54

de Unity, vi que no sucede 00:42:56

y lo han ido quitando, debe ser, en las 00:42:58

últimas, que es que cuando 00:43:01

creas un script llamado game manager, antes aparecía 00:43:02

una tuerquita y ya no 00:43:05

bueno, era solo una ayuda visual para 00:43:06

tener claro cuál era el game manager 00:43:08

y esa de la tuerquita 00:43:11

bueno, venía bien pues porque 00:43:12

era más visual, significa 00:43:14

que cuando a un script lo llamamos game manager 00:43:16

pues algo tiene de especial para que 00:43:18

le pongan otro 00:43:20

icono 00:43:21

propio, ¿no? 00:43:23

y esto es porque básicamente por convención 00:43:26

también 00:43:28

suele haber un script en el juego 00:43:29

que se llama Game Manager, en el que se van estableciendo, puede haber más de uno realmente, con otros nombres, pero bueno, que Game Manager es, digamos, un script en el que, digamos, todas las mecánicas, bueno, la palabra no es mecánicas, 00:43:32

todas las variables o los elementos de programación que vayan a ser recurrentes en todo el juego, como sucede aquí, pues que sea entre diferentes niveles y no sea solo de un nivel, pues es este gestor de juego y es donde vamos almacenando información para desde este script irla gestionando entre distintos niveles. 00:43:47

Como he dicho antes, para que esté en un nivel superior al resto de scripts que operan en el componente que los asignes y que esté siempre accesible o pueda hacer operaciones de más alcance. 00:44:07

En este caso, y es un ejemplo importante a tener en cuenta, ¿para qué serviría esta lógica? 00:44:23

que es este, el de crear funciones estáticas, perdonad, variables estáticas. Cuando creamos una variable estática, ¿vale? Y lo mismo, por defecto, una estática para poder acceder desde otros scripts y poder modificarlo y acceder a estas variables, pues habría que hacerla pública, ¿vale? 00:44:33

Luego, al declarar la variable, pues ponemos el tipo de variable que es, ¿no? Un int, un string, un flow, lo que sea. Podría ser lo que sea. Y luego el nombre que tiene esta variable. Hasta aquí, como siempre. 00:44:52

Lo único que ha cambiado es que, siendo pública, aparte, digamos que permanece, por eso de estática, permanece incluso cuando se para un nivel, ¿vale? Y se recarga en otro nivel otros scripts. 00:45:05

Esto, como tenemos una clase llamada GameManager, que es pública, y una variable que es pública, ¿vale? Esto, como ya vimos en su momento en otros scripts, siempre ya, desde cualquier otro punto de los scripts, abro este, por ejemplo, a ver si quiere que... 00:45:18

A ver, espera, voy a ir agrupando porque si no tengo aquí un montón de ventanas y no es lo que quiero. Vale, en este, por ejemplo, bueno, veis que aquí lo que estoy haciendo, tengo un static que se llama lives, ¿vale? Y yo aquí, sin haber creado ningún tipo de variable antes, puedo hacer directamente a la variable lives, simplemente poniendo, ¿vale? 00:45:36

Fijaos que tengo otra, así rápidamente, que se llama username, que ahí es donde vamos a almacenar el nombre del jugador, por cierto, ¿vale? Pues si yo aquí quisiera que, ¿vale? El nombre del jugador cuando cargara la escena 1, ¿vale? Fuera Pepito, ¿vale? Independientemente de lo que haya puesto en un input field o como lo hayamos asignado, yo puedo aquí decir, ¿vale? Pues que el username sea Pepito, ¿vale? Como es un string, pues habrá que ponerlo como un string, ¿vale? 00:45:59

Es verdad que hay que acordarse de qué tipo de variable es, o bueno, ponerte encima y veis que dice static, string, ¿vale? 00:46:29

Pero veis que no da error, yo puedo acceder a variable estática, a la clase, y a una variable estática sin tener que capturarla de ningún lado, ¿vale? 00:46:35

Tengo aquí la dificultad, las vidas, ¿y cuál más había puesto? Ah, bueno, y el username, que ya lo he puesto, pero aquí está, username, ahí está, ¿vale? 00:46:44

game manager username y eso es lo bueno que podemos hacer desde cualquier momento voy a 00:46:53

guardar esto y ahora cuando cargue aquí algo ha pasado vale cuando cargue el nivel al darle a 00:46:57

jugar vais a ver que pone ya pepito porque yo tenía ya establecido que pusiera lo que esté 00:47:05

guardado en esa variable game manager punto username que es un string que lo muestra aquí 00:47:10

entonces 00:47:17

básicamente hay que tener la lógica 00:47:19

en este momento 00:47:23

de que va a haber un script en el que vamos a 00:47:23

poder ir guardando 00:47:26

desde distintos scripts o momentos del juego 00:47:27

variables para que estén ahí almacenadas 00:47:30

y poder recuperarlas 00:47:33

¿vale? entiendo que esto además 00:47:35

es una liberación, también hay que ser cauteloso 00:47:36

con qué se usa y qué nombre se ponen 00:47:39

para que no haya conflictos con 00:47:41

variables que hay en los propios scripts 00:47:42

pero en los otros scripts ya 00:47:44

Porque por ejemplo lives es a lo mejor una variable muy fácil de crear en otro script y la sobre escribes y ya empiezan los problemas. Pero bueno, veis que es una forma rápida y sencilla de acceder a variables. 00:47:46

Entonces, voy a ir al menú de configuración. No guardo, no quiero los cambios. Aquí en este canvas, voy a ver si me habéis escrito algo. No. En este canvas he generado, aparte de la imagen de fondo de 1920x1080, que cuadra con el fondo, encima de eso he puesto otros tres elementos. 00:48:01

Uno de ellos es el slider, otro de ellos es el input y otro es un botón, que este no tiene más complejidad que los anteriores, un botón que lo que hace es, con ese load scene, cargar la escena cero, que es la de el menú inicial. Así que el botón, pasamos de él porque ya está más o menos establecido. 00:48:25

Vamos con el input primero, que me parece un poquito más fácil 00:48:44

El input, al final cuando creamos un input 00:48:48

Y atención, esto es lo que pone 00:48:51

Se pueden crear inputs con el texto antiguo, el legacy 00:48:53

Que se llamará luego por código de una forma 00:48:57

Que es el que de hecho he usado yo 00:49:00

Si voy a un script que luego vamos a ver 00:49:02

Pues tengo una variable de tipo texto 00:49:05

Que no es lo mismo que lo que pone 00:49:09

que si aquí cargamos el TextMeshPro, esta librería, va a haber otra. En realidad el funcionamiento es igual, solo que tiene más opciones. 00:49:12

Podemos hacer el TextMeshPro, Ugi y voy a poner texto TMPro. La única diferencia que hay entre estos dos es que cada uno hace referencia 00:49:20

a un tipo de componente. Cuando yo tengo un TextLegacy, aquí pone Text. Ya está. Si yo tengo un TestMeshPro, voy a crear uno aquí rápido, 00:49:35

un elemento que tenga TestMeshPro, el componente, o simplemente el texto. Se va a llamar TestMeshPro. ¿Vale? Cada uno tendrá más... 00:49:46

Uno tiene el TestMeshPro y por eso existe, tiene más opciones que el Text, pero a nivel de código, la variable que hay que usar para un TestMeshPro 00:49:56

es esta. Si usamos el TestLegacy es esta. Aparte de eso, luego casi todas las propiedades son iguales, aparte de que TestMeshPro tiene más, pero las básicas son iguales. 00:50:03

Esto lo pone en el tema, pero por si hubiera alguna duda, dicho queda. 00:50:16

Entonces, cuando hacemos un input, dentro tiene el espacio, digamos, que destinado... Vale, bueno, perdonad, esto es otro texto que he incluido dentro de este para que cuando arrastremos el input se mueva con él, ¿vale? 00:50:20

Pero básicamente, veis que va aquí esto de nombre usuario, es otro texto, que veáis que se pueden incluir más elementos dentro del otro, que es un texto simplemente para poner un encabezado de que es el nombre del usuario, que no es el input en sí. 00:50:46

Y luego está el input, porque me estaba haciendo un lío con la jerarquía, el input que dentro, en su interior, tiene esa caja del color que indiquemos aquí, que es una imagen, la podemos poner roja, blanca, etc. 00:51:01

Y es también donde se gestionan los cambios de valor que hagamos luego en los dos textos que tenemos dentro. 00:51:14

Es decir, tiene una imagen que también tiene estados de variación de su color, como pone aquí, para las transiciones, para marcar que estamos dentro, etc. 00:51:22

Y que salimos, etc. Veis que se oscurece, etc. Que eso está definido en estos colores que tiene aquí o se pueden poner incluso alguna animación. 00:51:32

Lo que pone también en el tema, pero básicamente están ahí las interacciones. Con esto se define la caja y luego dentro hay dos tipos de texto. El placeholder, que es en grisáceo donde pone el mensaje de, oye, ¿qué instrucción quiero poner aquí? Pues en vez de escribir tu nick, pon tu nombre. 00:51:44

Y este texto en realidad, aunque se puede capturar por código, lo que está esperando es como una ayuda visual para que temporal además, que de hecho eso es lo que quiere decir placeholder, está indicando que ahí lo que habría que poner es el nombre. 00:52:01

Donde de verdad se escribe el nombre es en este texto. Cuando lo escribimos al pulsar, vais a ver que yo cuando escribo aquí, empieza a escribir y básicamente se está volcando lo que yo escriba en este campo que hay aquí, en este parámetro. 00:52:20

Lo estamos haciendo en vivo y se está volcando ahí, ¿vale? Esto lo que hay que pensar es que en algún momento nosotros podemos llegar a leer este campo de texto y su contenido para guardarlo como, en este caso, en la variable pública que se llama username, ¿vale? 00:52:36

que luego ya cuando tengamos el hat 00:53:00

pues también lo que va a hacer es 00:53:02

poner el username text 00:53:04

pues el texto que hayamos guardado ahí 00:53:06

¿sí? 00:53:08

entonces, a ver, me pongo aquí 00:53:10

vuestra pantallita por si me ponéis algo, vale 00:53:12

sigo, y esto no sé 00:53:14

por qué 00:53:16

sí, me pregunta alguien 00:53:17

adelante 00:53:20

hola 00:53:21

justamente la 00:53:23

parte del if y el else 00:53:26

del username 00:53:28

podríamos poner que si 00:53:29

no pones ningún nombre 00:53:31

te ponga como un name 00:53:33

o no name 00:53:36

de forma genérica 00:53:37

me va a hablar de esto, ¿no? 00:53:39

aquí ya está eso, dice 00:53:41

si la variable estática 00:53:43

está vacía, es decir, nunca se ha introducido 00:53:45

nada, porque por defecto 00:53:48

cuando arrancamos el juego está así 00:53:49

y por tanto está vacía, hasta que 00:53:51

guardemos algo, si está vacía 00:53:54

pone player desconocido 00:53:55

Este es el texto que pone si no ponemos nada 00:53:58

Ah, vale 00:54:00

No está vacía, es decir, se ha introducido ya algo 00:54:01

El username va a ser 00:54:04

Player, como siempre va a poner esa 00:54:06

Coletilla de player, más 00:54:08

Y después, dejamos un espacio 00:54:10

El nombre que se ha guardado en esa 00:54:11

Variable estática 00:54:14

Del nombre, que esa variable estática 00:54:15

Solo se rellenará cuando escribamos algo aquí 00:54:18

Y se va a rellenar además 00:54:20

Porque lo hemos puesto 00:54:22

Aquí, ¿vale? 00:54:24

Es decir, cuando, a ver, esto ya empieza a ser un poco jaleo de ir viendo en qué parte pongo cosas, no sé, y es de lo que se trata. Simplemente que sepáis que aparte de lo que es el funcionamiento del juego, si estáis empleando, veis que yo aquí en scripts tengo los scripts del juego de la tarea 3, que podéis usar la tarea 3 o lo que queráis, que tenga una cierta lógica de que al dar a play haya vidas y cuando muera vuelvas a la pantalla de inicio. 00:54:26

Que me da igual que sea una bola o sea otra mecánica, por si no hicisteis la tarea 3. Pero realmente de User Interface solo hay cuatro scripts. Y uno de ellos es el de cargar escena, que ya hemos visto, que es simplemente preparar para los botones ese script. 00:54:53

El de GameManager, como hemos visto, es solo tener preparadas en un punto superior variables que nosotros podamos rellenar con cosas, ya está, ¿vale? Y luego tenemos esta, que es el que tiene chicha y ahora lo vamos viendo, el que vamos a asociar este ConfigMenu al Canvas para ir gestionando todo lo que tenemos aquí, ¿vale? 00:55:11

Todos estos inputs, aquí he preparado como serialized field varios elementos, ¿vale? 00:55:39

Y luego hay otro que es el hat manager, que es el del hat cuando jugamos, que tiene los corazoncillos, ¿vale? 00:55:45

Vuelvo a... para que lo veáis. 00:55:50

Este hat, y bueno, antes lo que me habéis preguntado, si no has puesto ningún nombre, pone por defecto player desconocido. 00:55:52

Cuando pongamos algún nombre, este desconocido se ve reemplazado por lo que esté guardado en el game manager, ¿vale? 00:56:00

Y este HUD tiene ese comportamiento, aparte de otra imagen, ¿vale? Aquí si vamos al canvas, este canvas pues tiene esta imagen, ¿vale? Pues que irá cargando, según las vidas que nos queden, irá cargando una imagen u otra, ¿vale? En este caso lo que se proporciona son varias imágenes y cuando morimos vais a ver que de pronto se cargará, vuelvo a abrir aquí, lo que se va a cargar es la imagen que se llama 00:56:05

Live 2, que está ya hecha para que muestre esto. 00:56:36

En el tutorial de Álvaro, de hecho, lo que hace es como ir recortando la imagen, 00:56:40

cambia las dimensiones de una única imagen para que se vayan viendo un corazón u otro. 00:56:44

Se pueden cargar imágenes distintas, recortar, bueno, pues ya eso es pensar cómo se hace y cómo se muestra. 00:56:47

Pero son cuatro scripts, por eso digo que quiero que quede claro, al menos como lo he resuelto yo, 00:56:54

siempre puede haber otras formas y con más elementos, 00:56:59

Pero son estos cuatro scripts y me voy a centrar en esos para que veáis un comportamiento de cómo se puede conseguir esto, ¿no? Vale, sigo con el input, ¿no? Estamos aquí. Tiene un placeholder que de este por defecto solo vamos a indicar pues ese mensaje de ayuda de pon algo aquí y el de texto que es el que sí que queremos, del que queremos recoger el texto, ¿vale? 00:57:04

recordad, vale, y me voy a este 00:57:31

config menu 00:57:33

joder, espera, porque esto siempre se me abre 00:57:34

espera un segundo, que yo creo que lo puedo 00:57:37

asociar aquí, un segundo 00:57:39

nada, bueno, lo tengo aquí 00:57:42

vale, lo que se han preparado 00:57:45

esos serialize field que os he 00:57:47

enseñado antes, y mira, lo pongo aquí abierto 00:57:49

para que lo veamos en paralelo 00:57:51

aquí en el canvas, vale 00:57:53

estos campos 00:57:55

que tenemos aquí, se corresponden con 00:57:56

los que se han creado en este 00:57:59

en este config menu, ¿no? Es el mismo 00:58:00

menú. ¿Vale? 00:58:03

Entonces, hay que pensar. 00:58:05

Yo, dentro de lo que 00:58:07

se pide la tarea y lo que nos interesa, 00:58:09

lo que voy a querer es 00:58:11

coger un texto o gestionar un texto, 00:58:12

¿vale? Una variable de tipo texto. 00:58:15

Recordad que esto, las tipos de 00:58:17

variables que se llaman con un 00:58:19

nombre de clase, como slider, texto, etcétera, 00:58:21

básicamente es el nombre que tiene 00:58:23

el componente. Se llama texto 00:58:24

y por eso el del testmespro se llama 00:58:27

de otra forma, porque es que tiene 00:58:29

un componente aquí, ¿vale? que se llama 00:58:30

texto, entonces siempre que carguemos 00:58:32

o hagamos un get component 00:58:34

de un componente 00:58:36

¿vale? se va a llamar como 00:58:38

se llama aquí, casi siempre, no siempre 00:58:40

pero casi siempre 00:58:42

¿vale? luego va a haber otro 00:58:43

de tipo slider porque voy a querer 00:58:46

jugar con 00:58:48

en el slider con este 00:58:50

esta variable que se llama slider 00:58:52

que al final es la que tiene los valores de cuánto 00:58:54

vale el slider, si os fijáis, yo cuando 00:58:56

muevo esto con value puedo ir 00:58:58

gestionando desde el propio juego 00:59:00

voy al moverlo, al ser un slider interactivo 00:59:05

voy, fijaos aquí, cambiando el valor de esto 00:59:08

¿Veis que cambia? Igual que yo puedo arrastrar por código 00:59:12

digamos, cambiar este valor por código y veis que también se ve reflejado 00:59:16

en el juego, ¿no? Vale, entonces 00:59:19

aquí estamos preparando esas variables, una para jugar con el slider 00:59:23

recoger el valor, otro de texto de dificultad, que básicamente es que he añadido aquí un campo que pone el nombre del nivel, ¿vale? 00:59:28

Que irá asociado a cada uno de los niveles del slider, ¿sí? Y luego, lo que no es el texto en sí, sino que podamos interactuar con un input field, ¿vale? 00:59:36

Porque en cierto momento, nosotros lo que vamos a ir es tocando este input field y lo que recogemos es el texto, 00:59:49

Pero son dos entidades distintas, ¿vale? Bueno, luego veis que los textos de dificultad, como voy a poner varios textos según el nivel, ¿vale? Esto de fácil, chupado, etc. Pues lo que va a ir cogiendo es cuatro textos que tengo preparado aquí en un array de strings. 00:59:57

Vale, muchas cosas, pero más o menos me vais siguiendo, ¿verdad? Ahora vamos viendo la lógica de cada cosa. Vale, vamos otra vez con el texto, ¿eh? Y me voy a ir a este menú y lo mismo, en el Config Menu habrá que ir también arrastrando cuál de estos elementos de la jerarquía es al que hace referencia esta variable, que por eso lo hacemos SerializeField. 01:00:14

Para luego poder decir dificultad texto, realmente lo que hago es cambiar el componente o coger valores también del componente texto. Este slider, si lo arrastro aquí, pues tendré que arrastrar el slider que me interese, que es este que tengo aquí, lo arrastro y ahí está. 01:00:42

Entonces ya puedo acceder a esto que tengo aquí, ¿vale? Después del punto pues saldrán estas propiedades en general, ¿vale? Entonces ya una vez establecidos las variables en sí, bueno, lo primero es en este array, por esto estas llavecitas de strings, ¿vale? 01:00:57

Y según se carga este nivel, no voy a querer que aparezcan otros, cuando aparezca este nivel va a haber un texto de dificultad, ¿vale? 01:01:18

Que vamos a crear un array de cuatro posiciones con los cuatro niveles por orden de dificultad, ¿vale? 01:01:29

Y aparte, cuando carga el juego, voy a aplicar esto que yo he llamado, que es un método que he creado yo, ¿vale? 01:01:37

Que se llama updateSlider. 01:01:45

Básicamente, así dicho, lo que hemos creado o lo que hay que crear es un método que sirva para ir guardando en esa variable estática la dificultad que vayamos cambiando, ¿vale? 01:01:47

En este caso, la dificultad con el slider. 01:02:00

Y por otro lado, un método que lo que hace es guardar en la variable estática el texto que hayamos metido en el inputFill, ¿vale? 01:02:03

Son dos. 01:02:12

Uno sirve para los cambios que hagamos con el slider y otro el que hagamos con el input field. Vamos con el del input field, vuelvo, porque al final este es el más sencillo. Fijaos que solo tiene una línea. ¿Qué es lo que estoy haciendo yo aquí? Preparar en público este método llamado update input para que los cambios que vayamos haciendo se guarden en el game manager username, que era esta variable estática. 01:02:12

Y lo que va a coger es el input username punto text. Esto así dicho rápido. Lo que estamos haciendo es decirle que, voy al input username, que cada vez que se cambie, estoy en el input username, son tantas cosas que por eso voy recopilando. 01:02:41

Perdón que a veces puede ser un poco plomo, pero prefiero que vaya más a paso. Si yo le digo que cada vez que se cambie un valor, coja del canvas, arrastro el canvas aquí y lo coge. 01:03:02

Que dentro de las opciones del canvas, aquí estaba, perdón, que coja el método llamado configMenu y yo he hecho ahí un método que se llama updateInput, que lo que hace es cada vez que cambie el contenido, directamente me lo guarda en la variable estática, ¿vale? Pues ya lo tengo preparado. 01:03:18

Ahora, al final, lo que estoy haciendo aquí es que cuando yo escriba un texto, cada vez que cambio este valor, según lo que hemos puesto aquí, cada vez que cambio este valor, se va a ejecutar ese, se va a recargar, digamos, ese método, se va a llamar y vas a decir, vale, por lo que yo haya escrito, que se guarde en el GameManagerUserName. 01:03:40

Bien, vuelvo a enseñar que eso es básicamente una variable de tipo string que tenemos aquí, que luego podremos llamar desde cualquier sitio. 01:04:00

Entonces, ¿qué faltaría en la ecuación? Que en todo momento sepamos o indiquemos claramente cuál es ese texto que tiene que guardar, ¿vale? 01:04:11

Y el que tiene que guardar es el texto que está dentro de input username. ¿Por qué? Es decir, tenemos por un lado el texto de la dificultad que se va cambiando y aquí tenemos el texto del input field, que es, creo que antes os he dicho que un texto era otro, 01:04:24

Pero básicamente este texto va a estar referido al texto de la dificultad, que es este que tenemos aquí, que se une aquí. Ese es el texto a secas. Y luego, por otro lado, tenemos el input field, que es este texto que tenemos aquí en el input field, que no es el mismo. 01:04:43

Perdón, que antes os he hablado y me he liado. Pero el input field tiene un campo de texto suyo, ¿vale? Entonces, hemos dicho que coja de este input field que hemos arrastrado, lo dejo de tener aquí, de este input field que hemos arrastrado aquí, ¿vale? Y que dentro tiene el valor que vayamos escribiendo en este texto, ¿vale? Y lo guarda en el GameManager. 01:05:00

Eso es lo que hace, es que en todo momento al cambiar el valor del input field, pues se va guardando en esa variable estática y luego como en el hat lo que hemos puesto, a ver si me sale, en el hat lo que hemos puesto es que si no se ha cambiado nunca, si nunca se ha introducido nada en el, bueno, todo esto se pone en el start. 01:05:19

al arrancar el nivel con el 01:05:43

hand manager, dice 01:05:46

hemos creado tres variables que lo que hacen es 01:05:47

que pongo de username 01:05:49

que pongo de update 01:05:51

de vidas y también no de dificultad 01:05:52

que eso os lo cuento después si da tiempo 01:05:55

pero es para influir por ejemplo 01:05:57

en el rigid body de la bola 01:05:59

entonces 01:06:01

aquí nuevamente en el 01:06:02

hand manager, que de esto no hemos hablado 01:06:05

yo en el hand manager también he creado 01:06:07

un script que voy a ir 01:06:09

añadiendo todas las 01:06:11

los serialize field, todas las variables 01:06:13

que me vaya a interesar luego ir cambiando 01:06:16

de ese hand manager, o incluso 01:06:18

remitiendo a un rigidbody de la bola 01:06:19

estoy accediendo al rigidbody de la bola 01:06:22

para luego cambiar sus propiedades 01:06:24

de mass y de drag, para que 01:06:26

según la dificultad que pusimos 01:06:27

en el slider 01:06:30

según si es 01:06:32

el nivel 0, el 1, el 2 01:06:34

o el 3, de la barra 01:06:36

y se ha guardado, pues 01:06:38

va a poner un peso 01:06:40

y un drag diferente, por tanto la bola 01:06:41

pues tendrá, será más fácil de mover 01:06:44

o caerá más rápido o bueno 01:06:45

los comportamientos en este caso de la física 01:06:47

vale 01:06:49

vale, entonces 01:06:50

básicamente estamos 01:06:54

usando nuevamente este KeyManagerUserName 01:06:57

como gestor luego para cambiar 01:07:00

un texto, vale, que es este 01:07:01

que tenemos aquí, que es el texto 01:07:03

que en el nivel 01:07:05

de 01:07:07

juego 01:07:08

no guardo por si acaso, ¿vale? que tengo aquí preparado 01:07:11

aquí tengo un canvas con su propio 01:07:14

con un texto aquí preparado 01:07:16

que lo que va a escribir es lo que yo le diga por código 01:07:20

por eso en su canvas, ¿vale? yo he dicho 01:07:22

que lo que tiene que cambiar es ese 01:07:26

username, ¿vale? eso que hay ahí, lo arrastra 01:07:29

y ya pues sabe que ahí es el texto que tiene que cambiar en base 01:07:31

a esto que 01:07:35

esto que yo le estoy diciendo aquí 01:07:37

¿Vale? ¿Me seguís con el texto? 01:07:40

Voy rápido, sé que es mucho lío 01:07:47

Así que todas las dudas que tengáis 01:07:49

Yo las resuelvo 01:07:51

Esto es ir siendo muy esquemático 01:07:52

Y decir, aquí voy a coger algo 01:07:56

Tenerlo muy claro, escribirlo 01:07:58

¿Dónde se guarda? 01:08:00

Esto que estoy cogiendo, en tal sitio 01:08:02

Y luego, ¿dónde se carga? 01:08:04

E ir, preparar la variable que sea 01:08:05

Necesaria y cargarlo 01:08:08

Bueno, sigo 01:08:11

Sí, sí, es denso. Es denso y además cuesta. Es ir desgranando poco a poco. Creo que alguna vez os hablé de lo que es el pseudocódigo. Bueno, no es pseudocódigo, no sé cómo se llama, pero en programación, en la ingeniería de informática, que os lo cuento, pero yo no es que lo haya hecho, yo no soy programador, ni mucho menos, pero por amigos que tengo y gente que conozco, ellos para entender lo que tienen que hacer antes de meterse en el código, en una hoja van escribiendo. 01:08:14

En el nivel 1 voy a tener un slider que al moverse va a guardar en otro script que se llama tal esto, el valor del slider. Una vez ha guardado en el HUD se va a ver reflejado, ponerlo con lenguaje natural, un poco esquemático pero con lenguaje natural, para tener siempre en cuenta de dónde a dónde vamos, porque si no esto se va amarañando y es complicado. 01:08:42

Pero básicamente es eso, es ir sabiendo de dónde cogemos contenido, dónde guardamos esa variable y luego de dónde se recoge. 01:09:11

Dicho así es fácil, pero si lo ponemos por escrito, pues es más fácil no perderse. 01:09:20

Y a lo malo es eso, que hay muchos capitulitos y muchos apartaditos que tampoco hay que hacer de una. 01:09:25

Primero hacemos este update username y cuando ya funciona vamos a lo del slider, poco a poco. 01:09:30

Pero sí que intentando resumirlo o ponerlo todo dentro de scripts que congreguen. En este caso, el gestor del HUD tiene tres funciones, básicamente, que es la del nombre, la de las vidas que tiene y la imagen que carga para demostrar esas vidas y el peso que tiene la bola. 01:09:37

Pero lo pone todo dentro de un único script, porque si también se digrega mucho, también se vuelve una cantidad de scripts que hay que ir conectando e ir moviendo que se vuelve un poco tedioso el tema. 01:09:56

vamos con el slider 01:10:07

si os parece 01:10:10

bueno, la vida 01:10:11

esto también me lo quito 01:10:14

de aplicároslo 01:10:16

aquí es una imagen 01:10:18

que se va cargando, por defecto 01:10:20

el AD3, pero básicamente 01:10:22

esto se debe a que cuando 01:10:24

cuando empieza el nivel 01:10:26

hacemos esto de 01:10:30

cargar vidas 01:10:31

y esto de cargar vidas es 01:10:33

si el game manager, las vidas 01:10:35

en algún momento han llegado a cero 01:10:38

es decir, ya hemos jugado 01:10:40

y fueron 01:10:41

y llegaron a ser 01:10:42

cero 01:10:45

directamente ya guarda B3 para tenerlo 01:10:47

ya preparado de que cuando reinicie el juego 01:10:50

sean tres, ¿vale? 01:10:52

pero básicamente en todo momento lo que tiene que ir cogiendo 01:10:53

son la cantidad de vidas 01:10:56

que tengamos guardada en el 01:10:58

game manager y de hecho 01:11:00

si no me equivoco 01:11:01

a ver, un segundo 01:11:03

nada, no, os iba a enseñar 01:11:04

una cosa que no es real 01:11:08

pero eso, que 01:11:10

lo que es el 01:11:11

joder, es que se me está cambiando todo el rato 01:11:13

el este, si al empezar 01:11:15

el juego no hemos hecho nada 01:11:18

pues pónmelo en 3, si no, cada vez que yo 01:11:19

vaya metiéndome en ese nivel, no toco esto 01:11:22

¿vale? salta este bucle 01:11:24

y solo se recarga 3 cuando 01:11:26

son 3, si no, lo que se irá haciendo es 01:11:28

que se irán restando vidas, ¿vale? 01:11:29

recordad que en el juego 01:11:32

o en lo que es el juego vuestro de la bola, cuando se cae por el precipicio tendremos que poner que GameManagerLive sea una vida menos. 01:11:33

En ese caso sí que hay que tocar alguno de los códigos que teníamos antes. Es decir, si nos metemos en donde precipicio, nos meteremos, a ver si quiere enseñármelo, 01:11:45

precipicio, aquí está 01:11:56

¿vale? y aquí metemos mano 01:11:59

a GameManagerLives y restamos 01:12:01

uno cuando se cae, ¿vale? pues empezamos 01:12:03

con tres realmente, dos, uno 01:12:05

y cuando es cero, aparte de que esto 01:12:07

ya obliga a cargar 01:12:09

cuando nos hemos caído la escena 01:12:11

cero, que es la que hemos puesto aquí 01:12:13

pues 01:12:15

también eso, nos va sirviendo 01:12:16

como lo estamos guardando en este GameManager 01:12:19

de orden superior 01:12:21

nos va sirviendo en todo momento para 01:12:22

ir cargando la imagen que nos corresponda. Esta imagen es un array que hemos creado aquí 01:12:25

con distintos sprites. Por un lado está el componente imagen, que es el que carga la 01:12:34

imagen. Si nos metemos aquí, hay un componente imagen que es el que carga la imagen. Y luego 01:12:41

otra cosa diferente es la variable de tipo sprites, que son las imágenes en sí. Si 01:12:47

Si os fijáis, aquí tengo por un lado la imagen, el componente imagen, que luego será el que cargue, ¿vale? Esto, que cargue sprites y luego son los sprites en sí, que en este caso guardamos en un array, ¿vale? 01:12:53

De tipo, aquí está, un array de tipo sprites, son los distintos sprites que, bueno, al ir arrastrando las distintas imágenes son este array de imágenes, ¿vale? 01:13:10

Y básicamente lo que vamos a ir haciendo, además, si os fijáis, es usar el índice en relación al array, es decir, el elemento 3 va a ser el de las tres vidas, el de 0 es cuando se han consumido, el de 1 es el de una vida, el de 2, el de 3, para que coincida y así directamente coincide también con el orden de arrays. 01:13:23

Es decir, si nos quedan dos vidas, directamente carga el segundo elemento, bueno, el tercero, ¿no? El 0, 1, el 2, elemento del array que coincide con el de las vidas. 01:13:49

Esto si no habría que dar más vueltas, pero si se hace coincidir, pues directamente cuadra, ¿vale? 01:13:59

A ver, que leo. Algo que queráis que repasemos. Voy muy rápido, voy bien. Me interesa sobre todo que lo vayáis entendiendo, ¿vale? 01:14:11

Luego hacerlo, esto que voy a decir es poco popular, pero las tareas sobre todo es para que vayáis entendiendo, más que yo entiendo que también la nota os interesa, evidentemente, pero sobre todo es que lo vayáis entendiendo y os sirva. Aunque no alcancéis el 100% o sea un acto, sobre todo es que lo entendáis. 01:14:25

¿por qué digo esto? 01:14:43

vuelvo a decir, sé que esto diréis 01:14:45

sí, claro, yo quiero mi punto extra 01:14:47

realmente el módulo se aprueba con el examen 01:14:49

¿vale? estos mini puntitos 01:14:51

que son décimas, que asignan 01:14:53

cada tarea, son extras que damos, pues oye 01:14:55

para que sea una especie de 01:14:57

acicate, de estímulo 01:14:59

para hacer las tareas, pero nuevamente 01:15:01

lo importante es que se entiendan 01:15:03

lo digo porque si copiáis esto y luego 01:15:04

es solo por el AERTO 01:15:07

pues no es el mejor enfoque 01:15:09

pero bueno, aquí cada uno ya que haga lo que le parezca 01:15:11

por supuesto yo tengo mi opinión de profesor yo tengo dudas que me han surgido con la tutoría 01:15:13

pero fuera de lo que pide la tarea vale pues si te parece dado que seguramente me costará 01:15:18

responderlas además porque irán por otros sitios vamos a seguir con lo que dijo la compañera del 01:15:22

slider y al final vemos qué dudas son y si te las puede responder bien y si no pues las dejamos para 01:15:29

el foro vemos cómo resolverla vale que depende de la dificultad igual ahora me preguntas cómo 01:15:35

puedo hacer algo complejísimo ahí me vas a pillar seguro vale vamos con el slider el slider es lo 01:15:40

mismo que hemos visto hasta ahora no pero tiene un nivel de complejidad quizá más mayor 01:15:53

que me trabo aquí buscando las cosas tiene otra otra dificultad que es que lo que va recogiendo 01:15:59

son valores numéricos y valores numéricos de tipo float y hay que hacer 01:16:08

una conversión y vamos a verlo vale en este slider pues aquí ya como había 01:16:12

puesto hay otro texto para que lo he metido dentro de lo hecho hijo de lo que 01:16:19

es todo el slider vamos aquí está el slider en sí y he hecho otro padre otro 01:16:25

en ti para que todo se mueva de golpe pues un titular que dificultad y este 01:16:29

texto que es el que se va cambiando con el array que os he puesto antes que 01:16:33

Irá cargando el texto de este array de dificultad que tenemos aquí. 01:16:38

Pero vamos al slider. 01:16:42

¿Qué es esto aquí? 01:16:43

El slider, además, tiene bastantes elementos. 01:16:44

También lo indica el tema. 01:16:48

Pero bueno, sobre todo, se puede cambiar la imagen, 01:16:52

que es el handle, que es el manejador de lo que movemos. 01:16:55

Bueno, pues es una imagen. 01:16:57

Aquí podemos arrastrar otro elemento. 01:16:58

Indica, además, que es de los pocos elementos de User Interface 01:17:01

que es mejor escalar que arrastrar porque se puede pixelar vale cuando hagáis las pruebas si cuando 01:17:05

vayáis cambiando el tamaño del slider se os empieza a pixelar es de los pocos que sí que 01:17:11

hay que escalar vale de los que porque si no empieza a pixelarse es decir si yo lo que hago 01:17:17

es cambiar el fil área me voy aquí arrastrando aquí bueno no es phil sería esto vale el conjunto 01:17:23

sí que sobre todo cuando se haga de otras proporciones 01:17:32

veis que empiezan a distorsionarse elementos 01:17:35

entonces para el largo a lo mejor no os da problemas 01:17:38

pero el handle sí que os va a dar problemas 01:17:41

entonces es de los pocos que hay que preparar 01:17:43

si vais a meter la imagen de la bola 01:17:46

pues que tenga una resolución adecuada 01:17:48

por si se hace un poco más grande 01:17:50

pero vais a ver que es de los pocos que sí que se aconseja 01:17:52

hacerlo más grande con la escala 01:17:55

porque si no da problemas 01:17:57

vale, lo dicho 01:17:58

Tenemos este fill area, tenemos distintos elementos para cambiar un color, para decir que cuando va pasando la bola cambie de color, pero toda la chicha básicamente está en el padre, que es el que da aquí en el componente slider, el que va recogiendo en este value el valor dentro de lo que se haya cargado o no, la barra, el valor de carga. 01:18:01

Se va a interpretar como números. Aunque aquí ponga lo de fácil chupado, eso se va a ir relacionando en base al número que tengamos aquí. Va a cargar el slider del texto del array de dimensión 1, de posición 2 o de posición 3. Pero básicamente esto es lo que nos va a dar la gestión del slider. 01:18:25

importante, bueno, aparte de que el slider 01:18:44

se puede poner de arriba a abajo, de izquierda a derecha 01:18:47

por si queremos que suba o baje 01:18:49

¿vale? de una forma rápida 01:18:51

bueno, aquí se le ha ido la pinza 01:18:53

un segundito, vale 01:18:55

y por tanto 01:18:56

si queremos cambiar la dirección 01:18:59

no habría que rotarlo, ¿vale? que sería a lo mejor 01:19:00

el comportamiento 01:19:03

así primero que no vendría 01:19:05

sino que habría que cambiar la orientación aquí 01:19:07

¿vale? y de momento 01:19:09

me interesa que vaya de izquierda el 0 01:19:11

A derecha, el máximo, sería esta la configuración. Muy importante, habrá que configurar el slider con su mínimo y su máximo. En este caso, se pone de 0 al 3 porque queremos 4 niveles de dificultad. 01:19:13

Ten en cuenta que el 0 ya es un valor, ¿vale? El 0 será chupado, el 1 será fácil, el 2 será intermedio o yo que sé, algo así era, y el 4 será muy difícil, ¿vale? Entonces, esto va a llegar hasta donde nosotros pongamos aquí, del mínimo al máximo. 01:19:28

entonces yo ahora, si os fijáis 01:19:45

que he puesto que vaya del 0 01:19:48

como punto de partida, aunque también se podría cambiar 01:19:50

también podría ser que empiece en el 1 01:19:52

pues el 1 sería el valor de inicio 01:19:54

y a medida que voy arrastrando, veis que ahora 01:19:56

hay muchos más pasos 01:19:57

y hay otro valor 01:19:59

también importante que es 01:20:01

que aparte del límite, se puede 01:20:04

dejar, como viene por defecto 01:20:06

si no me equivoco, para que sea un float 01:20:08

y vais a ver que el valor ahora 01:20:10

que va cogiendo es de 01:20:11

un float porque tiene valores decimales o que sean números enteros. Aquí he cambiado algo del tamaño, 01:20:13

ya la he liado un poco, pero veis que cuando ponemos esto de whole numbers, hacemos que los 01:20:23

saltos sean entre unidades enteras. ¿Qué problema vamos a tener con esto? Que aunque aquí pongamos 01:20:29

esto de whole numbers, al nivel de código, esto está preparado para que funcione con floats, 01:20:36

con decimales, y lo que va a tener que 01:20:41

recibir es un float, ¿vale? 01:20:43

esto es una dificultad que hay ahí 01:20:45

a ver un segundo, a ver si encuentro 01:20:47

el por qué pasó esto 01:20:49

el fill 01:20:51

a ver un segundín 01:20:54

aquí el handle 01:20:55

algo que cambie aquí 01:20:56

que se ha descoyuntado 01:20:59

sería el 01:21:03

fill area 01:21:05

bueno, aquí 01:21:07

puede ser, a ver, un segundo, algo que cambia ahí 01:21:09

que se le ha ido un poco 01:21:11

bueno, un segundo 01:21:12

no, aquí no es 01:21:17

bueno, esto, bueno 01:21:20

si no tocáis nada raro, pues no 01:21:25

pasa esto de que se desconfigura el 01:21:28

tendría que hacer la prueba de 01:21:29

escalar, a ver 01:21:31

un segundo, eh, no sé 01:21:33

por qué esto ha cambiado, pero bueno, habría que ajustarlo ahí 01:21:37

y ahora sí que lo hace 01:21:39

bueno, algo, cuando he escalado 01:21:41

fijaos que ha pasado eso, bueno ya estamos otra vez 01:21:43

vuelve a estar mal porque tendría 01:21:46

que ajustar esto al valor que tenía 01:21:51

porque lo he cambiado en reproducción pero 01:21:53

es eso lo importante, lo dicho 01:21:54

para lo que nos interesa 01:21:57

que son niveles de dificultad no queremos decimales 01:21:59

preferimos que sean valores enteros 01:22:01

¿vale? y aquí 01:22:03

cada vez que se toque 01:22:05

cada vez que se cambie el valor hay un evento 01:22:07

ya preparado en los sliders 01:22:09

que como sucedía 01:22:11

en el de escritura en los input fields 01:22:13

Podemos poner que llame a uno o varios 01:22:15

Se pueden ir incluyendo más acciones 01:22:19

Y antes os he dicho que cuando cargamos otro elemento 01:22:21

El canvas, voy a hacer una cosa 01:22:25

Vienen aquí más cosas, se podría decir 01:22:27

No un script con métodos públicos que hemos creado nosotros 01:22:29

Sino decir directamente que el GameObject cuando lo toquemos 01:22:33

Se active o se desactive 01:22:36

Es decir, que cuando toque esto se desactive 01:22:39

Entonces vais a ver ahora que cuando, como está desmarcado que se desactive, cuando toque aquí el canvas se ha desactivado, porque cuando he tocado y se ha cambiado un valor, le he dicho que el setActive se vuelva falso, vuelve a una falsa. 01:22:42

Y en cuanto he tocado, efectivamente, este canvas ha pasado a ser falso. Entonces, hay muchas interacciones que se pueden hacer más allá de decir que lance otro script que tengamos ahí preparado, ¿vale? 01:22:56

Pero bueno, y que sean varios incluso. A ver, espera, que aquí justo he dejado el que no me interesa, que es este, lo resto, ahí está. Aquí yo tengo en el canvas nuevamente y en el método público, en el script config menu, tengo un script llamado updateSlider. 01:23:14

Vamos a ver qué es lo que hemos puesto. Aquí está. Y ahora hacemos que cuando toquemos algo del slider va a estar llamando a este método. ¿Y qué es lo que hacemos aquí? 01:23:33

Creamos dentro del método, está encapsulado dentro del método, una variable de tipo float que se llama dificultad. Y básicamente lo que estamos guardando en dificultad es el número que tengamos aquí en value. 01:23:46

Aquí va a ir guardando, en nombre de dificultad, el valor. Pero es un float, como os he dicho. Esto está preparado para funcionar con decimales. Solo que aquí podemos marcar una opción para que dé saltos en cada unidad. 01:23:58

¿Qué implica eso? Que para que luego no de problemas, hay que hacer lo que se llama una conversión explícita. Es decir, indicar que un tipo de variable cambie a otro tipo de variable si son compatibles. 01:24:12

Y hay una cosa que es que un float es muy fácil convertirlo en un int, porque básicamente es decir, oye, quítame los decimales y te quedas con la unidad. Para hacer esa conversión, creamos una variable de tipo int, que se llama dificultad int, y lo que hacemos es simplemente poniendo entre paréntesis delante de la variable de tipo float, esto sirve para pasar de float a int. 01:24:29

Para otras cosas no va a funcionar. Si ponemos delante de una variable de tipo float esta indicación de entre paréntesis int va a hacer una conversión. Entonces lo que coge aquí como float lo convierte a int. 01:24:55

Hay otras formas de conseguir esto, ¿vale? Hay métodos que son como de redondeo, esto de absolute o el round, ¿vale? R aquí, el round, ¿vale? O round to int, que también nos serviría para coger este valor que es un float y convertirlo en un int. 01:25:08

Pero bueno, digo que incluso algunos métodos ya podríais haber llegado a ellos, pero que sepáis que también de float a int se pueden hacer estas conversiones, haciendo esto del paréntesis. 01:25:28

Lo importante es que aquí estamos cogiendo el valor, en todo momento, cada vez que movemos, cada vez que movemos se lanza esto, recoge este valor, lo guarda en dificultad, lo convertimos a in, ¿vale? Pues cuando vayamos moviendo. 01:25:37

Y luego, este dificultad text, ¿vale? Aquí lo que estamos haciendo en todo momento es que estamos aludiendo a este dificultad text que habíamos guardado, es decir, que habíamos establecido con las cuatro variables del array para ir cambiando este texto, ¿vale? 01:25:49

y se irá lanzando un array, un elemento del array u otro, según la posición del array que lancemos, que coincidirá con la del tipo int. 01:26:08

Y por eso lo hacemos de tipo int, porque para que el array que tiene posiciones fijas se vaya lanzando, lo convertimos en tipo int. 01:26:20

Pero bueno, esto no es lo más importante. Lo importante es que en todo momento tenemos aquí dificultad como un float y dificultad int, 01:26:26

el valor del slider 01:26:33

también como un entero 01:26:35

y que vamos a ir haciendo en todo momento 01:26:36

guardar en la variable 01:26:38

estática llamada dificultad 01:26:41

el nivel de dificultad y aquí si que puede ser 01:26:43

float o int lo que nos interesa 01:26:45

vale 01:26:47

entonces digamos que 01:26:48

cada vez que tocamos el slider hasta aquí 01:26:51

estamos guardando por un lado 01:26:53

en la variable estática el nivel 01:26:54

de dificultad por un lado 01:26:57

y en otro estamos preparando para 01:26:59

que aquí nos muestre el texto de este array que habíamos generado aquí que de hecho está aquí 01:27:01

vale que tiene cuatro posiciones pues cargará este array pues según él la posición que tenga 01:27:06

pues irá cargando uno de estos strings en este campo de texto que tenemos ahí vale luego por 01:27:14

otro lado esto también se explica en el tema vale se pueden usar esto es un poco opcional se podría 01:27:20

de otra forma los player prefs 01:27:27

que los player prefs es, digamos, de hacer 01:27:28

un guardado que va 01:27:31

incluso más allá de las estáticas, de las variables 01:27:32

estáticas, las variables estáticas 01:27:35

funcionan mientras 01:27:37

está la ejecución de ese juego, es decir 01:27:38

en una partida, hasta que no 01:27:41

se apague la reproducción 01:27:43

hasta que no se pare el juego, básicamente 01:27:44

pues entre niveles y entre 01:27:46

elementos se pueden ir almacenando 01:27:49

esas informaciones, con los player prefs 01:27:50

básicamente lo que hacemos es guardar 01:27:53

en el ordenador, en el sistema operativo 01:27:54

en algún punto de nuestra memoria del 01:27:56

ordenador, variables o valores 01:27:58

que pueden ser rescatados 01:28:00

incluso entre partidas 01:28:02

es la diferencia, luego en el tema 01:28:04

también os pongo que los player prefs 01:28:07

se guardan 01:28:09

en el sistema operativo pero se pueden guardar 01:28:10

en archivos tipo json, esto es más avanzado 01:28:12

pero que digamos que se pueden 01:28:15

subir a una nube o se pueden subir y entonces 01:28:17

se guardan en la nube 01:28:18

con un nombre y se recogen en la nube con un nombre 01:28:20

de una forma más o menos 01:28:23

un poco más compleja, más larga, pero similar a esta, que es que nosotros podemos ir dando, igual que si tuviéramos un Excel, vamos a decir, podemos ir creando tablas 01:28:24

en las que poner en una casilla un nombre y en la siguiente el valor, o lo que estemos guardando, el valor de lo que guardemos. Aquí, por ejemplo, estamos diciendo 01:28:34

en los player prefs, los player prefs siempre aparecen, no hay que hacer nada extraño, están ahí y tienen sus propios métodos aquí, que se habla de ellos, 01:28:43

De hecho, se habla de todos los que tiene, se describen en el tema. Pero aquí en este momento, cada vez que movamos el slider, recordemos, en el slider, recordad que cada vez que toquemos, activa el método UpdateSlider. 01:28:52

Entonces, cada vez que toquemos, podemos estar guardando en ese sistema operativo, en ese archivillo, con el nombre clave, digamos, de dificultad, porque es lo que estamos guardando, ¿vale? Es el nombre que le estamos dando a este dato, pues lo que estamos guardando es el valor del slider. 01:29:19

Realmente aquí también podríamos poner dificultad directamente, porque es lo mismo, pero bueno, así queda más claro. Según lo recoge ya, mete este valor y lo va a meter como un float, recordad. Bueno, pues como un float. 01:29:37

Y eso significa que aparte de estar guardándolo en el Game Manager, yo también podré recurrir a los Player Prefs para recuperar datos. 01:29:49

Por ejemplo, aquí hay una cosa que es, esto ya es más opcional, pero lo de los Player Prefs, os lo digo un poco para que sepáis cómo funciona. 01:29:58

Pero una de las opciones es que cuando se arranca este script, que realmente se arranca cuando entramos en el menú de configuración, 01:30:08

Cuando damos al botón de config desde el menú inicial, nos metemos aquí y al arrancar dice, oye, si en algún momento se ha creado, esto es una booleana, al final es una condición que es una booleana. Es uno de los métodos que tienen los player prefs, que es si existe este código llamado dificultad, ejecútalo de dentro. 01:30:18

Si alguna vez ya se había creado 01:30:36

La primera vez que juguemos 01:30:38

No va a suceder 01:30:41

La segunda, en cuanto hayamos tocado el slider 01:30:42

Ya se ha generado este código 01:30:45

Este campo 01:30:47

Digamos 01:30:49

En las playerprefs 01:30:49

Y habrá guardado un valor 01:30:52

Entonces dice, si alguna vez has jugado y existe 01:30:54

Esta dificultad 01:30:56

Pues por defecto 01:30:58

Lo que es el valor 01:31:00

Voy a decir 01:31:01

Aludir aquí 01:31:03

El valor de 01:31:05

De este slider 01:31:06

Que sea el que habíamos 01:31:09

Coge ese float y pone ese valor 01:31:10

¿Vale? En base a ese nombre 01:31:13

Por eso, aunque 01:31:14

Fijaos 01:31:16

Es verdad que las player prefs se generan 01:31:18

Se generan cuando 01:31:21

Cuando 01:31:22

Eh 01:31:24

Digamos, sobre todo cuando se está jugando 01:31:25

Pero fijaos que yo ahora 01:31:29

Aunque pare la reproducción 01:31:31

Cuando le doy al play 01:31:32

se está cargando el último estado 01:31:33

que había dejado ¿vale? ya no es 01:31:36

entre niveles, es entre partidas 01:31:38

entonces yo ahora por ejemplo lo pongo en 01:31:39

normal ¿vale? 01:31:42

y paro ¿vale? ya las variables 01:31:44

estáticas han olvidado todo, se han descargado 01:31:46

el juego ha parado, podemos 01:31:48

habernos ido a apagar el ordenador 01:31:50

si esto fuera el compilado ¿vale? 01:31:52

pero bueno, ahora estamos digamos 01:31:54

recreando lo que pasaría en el compilado 01:31:55

si yo vuelvo a arrancar el juego, como estoy 01:31:57

en el mismo sistema operativo 01:32:00

y ese archivo de las player prefs 01:32:01

se ha almacenado ahí, lo buscará 01:32:03

y dirá, sí, sí existe esa 01:32:05

dificultad. Y por eso arranca 01:32:07

ya con el valor de 01:32:09

2 en este caso, ¿vale? 01:32:10

Que es en el que lo habíamos dejado. 01:32:13

Entonces, bueno, en los player prefs 01:32:15

el problema que tienen, esto se usaba 01:32:17

por eso se llama player preferences 01:32:19

se usaba, por ejemplo, 01:32:21

en las 01:32:23

máquinas recreativas 01:32:24

para guardar los listados 01:32:27

de los mejores, en plan, el número 01:32:29

uno hizo 50.000 puntos, el 2 01:32:31

30.000. El problema de los ordenadores 01:32:33

es que si buscas ese archivo y lo cambias a mano 01:32:35

pues es muy fácil manipularlo 01:32:37

para que de pronto te cargue lo que tú quieras. 01:32:39

Pero bueno, ya os digo que 01:32:42

esto es una especie de primer 01:32:43

paso o versión simplificada 01:32:44

de lo que se puede hacer con archivos 01:32:47

que se guardan a la nube y se almacenan 01:32:49

en sistemas, que es lo que sucede cuando 01:32:51

se juega juegos en la nube, que se van 01:32:53

guardando datos en la nube 01:32:55

o en una memory card, etc. 01:32:57

Pues hay otros sistemas con otros tipos de archivos, pero en esencia es lo mismo, que se pueden ir generando lo que se llaman keys, lo que se llaman códigos, nombres, a los que se pueden asociar valores y que se compruebe si existe ese código y si existe ese código que coja ese valor, ¿vale? 01:32:59

pero bueno 01:33:17

en esencia ese es un poco lo que está 01:33:19

lo que está configurado 01:33:21

luego cuando ya tenemos la dificultad 01:33:23

¿vale? en el HUD Manager 01:33:25

al que 01:33:27

digamos en cada nivel estamos 01:33:29

accediendo al RigidBody de ese nivel 01:33:31

porque lo arrastramos al 01:33:33

SerializeField, la bola 01:33:35

o porque aquí hiciéramos, aquí no lo he hecho así 01:33:36

lo he hecho por SerializeField pero un GetComponent 01:33:38

y ese componente del RigidBody 01:33:41

de ese nivel 01:33:43

pues luego podemos ir y decir oye 01:33:44

Guárdame en una variable local lo que valga dificultad, ¿vale? 01:33:47

Que es básicamente lo que se ha guardado como valor del slider cada vez que lo hemos ido cambiando, ¿vale? 01:33:54

Entonces, si lo hemos dejado en 2, yo aquí luego lo que puedo hacer es decir, 01:33:59

ah, vale, como si la dificultad es la de normal, que es la de 2, 01:34:03

esto también se podría hacer con un switch, ¿vale? 01:34:07

En vez de hacer tantas condiciones, pero bueno, en esencia es lo mismo. 01:34:10

Pues si la dificultad que habíamos guardado, que se guardó en esa variable estática, es 2, pues la masa de la bola, acedo al RigidBody, que lo había llamado como bola, y ya aquí puedo cambiar que sea más o menos pesada, que tenga otra inercia, que tenga gravedad, que no. 01:34:13

Y aquí, pues básicamente voy cambiando las condiciones y vais a ver que la bola es más pesada, sobre todo para el nivel que va rotando la tabla, es más pesada y tiene menos drag para que caiga más rápido de la tabla y sea más difícil. 01:34:33

Pues a medida que tiene más dificultad, en el 3 es donde más masa y menos drag tiene. 01:34:45

¿Vale? 01:34:50

Y con esto más o menos os he ido contando un poco todo, un poco rápido. 01:34:52

Luego, en el menú inicial, el botón de salir, simplemente para que lo sepáis, en el menú inicial, no lo guardo, en el de salir, lo pone también en el tema, además creo que viene hasta subrayaico y tal, que cuando queremos cerrar, cuando hagamos el compilado del juego, si queremos que al dar a ese botón, o cuando sea, se cierre el juego, está este método, el application quit. 01:34:56

Pero esto no se ve reflejado al reproducir en el editor. No se puede cerrar de esta forma porque si no, supongo que interpretaría que lo que tiene que cerrar es la aplicación de Unity. Entonces, la dejamos aquí y sabemos que funciona. 01:35:23

Ahí, bueno, se puede poner aquí también un debug log que indique larga, botón de salir y saldría, ¿vale? Pero realmente es esta línea la que sirve para cerrar el juego, ¿vale? Hay como otras formas de poner que cuando cliques como que simule que para el juego y tal, pero bueno, es más enrevesado, simplemente es que sepáis que aunque pongáis esta instrucción hasta que no compiléis, realmente esto no se va a ejecutar, por mucho que esté dando a este botón y esté bien establecido todo, pero vaya. 01:35:38

dudas 01:36:05

leo una que hay, el valor máximo 01:36:11

que tienes es 3, sería que la barra 01:36:13

se secciona en 3 partes 01:36:15

así que el botón de la barra 01:36:17

tiene 4 posiciones, inicio, claro 01:36:19

realmente tiene 4 01:36:21

porque tú empiezas por el 0 01:36:23

es decir, vamos aquí 01:36:25

input 01:36:27

no, input no 01:36:29

dificultad, vale, yo he cambiado 01:36:32

el slider, le he cambiado el nombre a dificultad 01:36:34

pero bueno, aquí slider 01:36:36

dificultad, que se puede cambiarlo en nombre sin problema 01:36:37

cuando tú estableces el mínimo 01:36:39

el valor 0 y el máximo el valor 3 01:36:41

0 es un valor 01:36:44

1 es otro valor, 2 es otro valor 01:36:45

y 3 es otro valor, por tanto 01:36:47

hay 4 posiciones 01:36:49

puedes ir de 0, 1, 2, 3 01:36:50

4 posiciones 01:36:54

lo mismo, aquí en realidad 01:36:55

en otros momentos, en una pantalla de carga 01:36:58

que un slider puede 01:37:00

servir para mostrar una pantalla de carga 01:37:02

mientras voy haciendo así, fijaos como la bola 01:37:04

si en el async, hay un apartado sobre los asyncs, va mostrándose esta carga, sirve, con decimales en este caso sí, 01:37:06

no queremos que haya valores, para cargar esa barra. Si yo quitara esto del handle, y dejo solo el fil área, 01:37:14

básicamente esto es una barra de carga. También puede usarse para eso. 01:37:24

vale, lo vuelvo a activar 01:37:29

vale, dudas 01:37:31

que yo por mi parte 01:37:33

he hablado mucho, entiendo que se ha 01:37:34

revesado, pero más o menos 01:37:41

lo veis, ¿no? 01:37:43

pues sí, planteame 01:37:45

la duda, si nadie más dice nada 01:37:47

será que no la sé 01:37:49

vale, a ver 01:37:51

una duda así chiquitita 01:37:53

por ejemplo 01:37:54

lo que es todo el HUD 01:37:56

del sprite y de los textos 01:37:58

si no quisiéramos ponerlo 01:38:00

lo que es en la cámara 01:38:02

la cosa es para ponerlo 01:38:03

encima de la bola y que le siga 01:38:06

como si fuera el típico juego 01:38:08

RPG, tendrías que trasladar 01:38:10

lo que es el HUD, ponerlo como 01:38:12

hijo de la bola 01:38:14

si, habría que hacer dos cosas 01:38:15

voy a ver 01:38:18

y claro, ahora que te lo estoy diciendo 01:38:20

si lo pones como hijo de la bola, cuando gira 01:38:22

la bola, se mantendría 01:38:24

arriba estático o giraría 01:38:26

al eje de la bola, no sé si me explico 01:38:27

Sí. Tú ten en cuenta, y para eso está esto de canvas, que tú aquí si dices que esté como un overlay, va a estar como un overlay. Eso es a nivel de visionado de cámara. Está casi pensado para eso, para hacer interfaces a nivel de menús, que se sobrepongan, que estén siempre en un mismo espacio. 01:38:30

Pero aquí hay otro render mode que es el de workspace, ¿vale? Y entonces tú si aquí le dices que con respecto a la cámara que la tengo aquí, le dices respecto a esta cámara que este canvas y veis que cuando se pasa a workspace, de pronto este canvas empieza a tener eje Z, empieza a tener otros, a ver, ahí, tiene otros valores, ¿vale? 01:38:49

de pronto le sale la 01:39:17

pinceta, etcétera, tú puedes coger ahora 01:39:19

y ese canvas, sí, hacerlo 01:39:21

hijo del 01:39:23

bueno, claro, es que esto es un prefab 01:39:24

habría que 01:39:28

desempaquetar probablemente 01:39:30

no, a ver 01:39:33

un segundín, eh 01:39:34

porque es lo que te digo 01:39:37

children of a prefab instance 01:39:39

ah, vale, no, es que yo 01:39:40

vale, el hat lo he metido como un prefab 01:39:43

entonces habría que 01:39:45

Liberar el prefab y meterlo como hijo de la bola. 01:39:47

Vale, entonces ahora, si yo moviera esto para que estuviera en posición con la tabla. 01:39:53

A ver, un segundín, ¿dónde está la bola? 01:40:05

Ahí está la bola. 01:40:08

Claro, es que es muy pequeño. 01:40:10

Aquí hay que ajustar el canvas para que esté con, vamos a hacerlo más pequeñete, a ver un segundo, voy, a ver, esto hay que hacerlo más pequeñito y hay que colocarlo en posición. 01:40:11

básicamente ahora 01:40:35

lo que pasa es que tiene unas dimensiones 01:40:44

descomunalmente grandes 01:40:45

ahora lo que, si te fijas 01:40:47

vale, ahí está, tenemos 01:40:49

ese canvas 01:40:51

¿vale? que se podría ajustar en el espacio 01:40:54

y si yo sigo 01:40:56

haciendo lo más pequeño 01:40:58

500 01:40:59

500 01:41:06

ves que ya va apareciendo como en el espacio 01:41:07

vale, a ver, un segundo 01:41:15

ahora vemos las pegas de esto, ¿vale? 01:41:16

¿Ves que se está moviendo con la bola? Lo que pasa es que he movido la bola o algo así, debe ser. 01:41:19

¿Dónde está la bola ahora? Bueno, vale, que aquí he cambiado algo. 01:41:24

Básicamente, ahora, un segundo. 01:41:29

Vale, vamos aquí. Y esto lo tengo que seguir haciendo más pequeñito. 01:41:33

¿Y dónde tengo yo esto? Ah, bueno, no sé por qué se pone ahí. 01:41:41

Vale, ahí lo pongo un poco más arriba. Habría que reajustar todo lo que hay dentro de ese canvas. Lo voy a hacer todavía más pequeño. Esto es porque también justo esta bola es muy pequeña. 01:42:02

Pero si lo colocamos ahí, habría que reconfigurar todo, pero fíjate, bueno, claro, aquí está sucediendo la cosa de que al estar vinculado con una bola que está rotando, está rotando alrededor, ¿vale? 01:42:20

Porque está cogiendo la fuerza. Habría que, por código, decir que siguiera el transform de la bola, ¿vale? Pero esto es usando el canvas, porque si te das cuenta, a ver, y un segundo, que esto me va a costar un segundo recordarlo, vale, lo lógico, ¿vale? 01:42:42

Esto es simplemente para que veas que los canvas, si tú los pones en el workspace y en relación a una cámara, tú, básicamente, este canvas es como cualquier otro elemento, ¿vale? 01:43:02

Y aquí, de hecho, lo que habría que hacer es eso, que siguiera la bola, pero que no la siguiera como hijo, porque entonces va a rotar, porque la bola en todo momento, fíjate que yo cuando me voy moviendo, la bola va rotando, ¿vale? 01:43:12

Porque le estamos dando con él, entonces rota con ello, por eso hace estas cosas raras. 01:43:28

Habría que asociarlo por código, pues que vaya cogiendo el transform position, ¿vale? 01:43:32

Y se mueva con position, para que no vaya adquiriendo estas rotaciones. 01:43:38

¿No valdría un MP object como padre y ambos dentro? 01:43:44

Sí, lo único malo es que como en este caso la bola siempre la estás rotando, 01:43:50

si lo que quieres es que se mueva con una fuerza de la bola, el padre no se está moviendo. 01:43:55

¿Sabes lo que te quiero decir? 01:44:00

Ah, vale. 01:44:00

Pero bueno, hay que buscar la manera de que, aunque la bola la movamos así, que lo que vaya leyendo en todo momento sea la posición de la bola y no todo, ¿sabes? 01:44:02

Que es lo que hace cuando lo haces hijo, ¿vale? Y eso por código ya lo sabéis hacer. 01:44:11

Entonces, pues que... Pero te vuelvo a decir, bueno, a lo que iba. En 3D Objects, en vez de meter desde UI, los elementos de la UI, que lo que hace es crear el canvas, 01:44:16

también se pueden crear como objetos 3D 01:44:25

entonces tú puedes ir aquí 01:44:28

y decir que se cree un texto 01:44:29

¿vale? que si le damos aquí 01:44:32

por ejemplo, este texto ves 01:44:34

que no se mete por defecto dentro del canvas 01:44:36

y sin embargo 01:44:38

ya está en Z 01:44:40

¿vale? entonces si lo que quieres cargar 01:44:41

es un texto 01:44:44

por ejemplo, simplemente se puede meter 01:44:46

como un objeto 01:44:48

o lo digo esto porque los textos sí que es verdad 01:44:49

que son editables 01:44:52

etcétera 01:44:54

Pero tú normalmente, cuando quieras cargar una imagen, también lo que puedes hacer es crear un plano, ¿vale? Y como textura ponerle una imagen y ponerlo ahí, ¿vale? Que no sería un elemento de User Interface. Lo que va variando es el contenido de un texto, pues los números, la vida, etc. 01:44:55

Y bueno, ya te digo que puedes hacerlo con una user interface, pero si solo quieres poner el nombre del personaje, lo puedes poner con un elemento 3D, que no es el de UI, sino que es un objeto 3D de este tipo. Creo que de hecho de esto también hablo un poquillo en el tema. 01:45:13

Y luego también un plano le puedes poner una foto o un corazón. Es decir, si tú aquí en el material que tengas, habría que crear un nuevo material, un material, material, material, y dices imagen, yo qué sé, el corazón. 01:45:27

Vamos a poner las vidas del corazón de esta forma. Desactivo esas y lo que voy a decir es que ese material, el albedo, sea una imagen de un corazón. De esto también hablaremos ya en otro momento. 01:45:45

pero fíjate que tú ya 01:46:01

a este plano le puedes poner 01:46:03

un material que sea 01:46:05

ese corazón, entonces 01:46:07

no, en X evidentemente 01:46:09

y será menos 90, entiendo 01:46:13

o no, más bien 90 01:46:15

lo que pasa es que ahora 01:46:17

está por el lado que no tiene que ser 01:46:19

pero que con esto también se podrían hacer 01:46:21

habría que meter un alfa para que lo 01:46:23

capte bien, etcétera, pero que puedes 01:46:25

meter elementos 01:46:27

luego que en realidad son elementos 3D 01:46:29

y nuevamente lo puedes asociar a la bola 01:46:31

pero bueno, con lo que hemos visto de la 01:46:33

UI, básicamente es como te he dicho 01:46:35

poner que su render mode 01:46:37

sea workspace, que básicamente es que 01:46:39

se convierte en un objeto con sus 01:46:41

con su transform, normal 01:46:43

aunque metas aquí luego los anchors y tal 01:46:45

en realidad aquí están sus 01:46:47

sus 01:46:49

parámetros, ¿vale? 01:46:50

vale 01:46:54

vale, vale 01:46:55

por ahí sería por donde yo tocaría más cosas vale la otra es ahora mismo no me acuerdo si 01:46:57

si lo mostraste es muy por encima en una tutoría o fue en un vídeo de álvaro cuando los sacs los 01:47:05

access no sé si me acuerdo si pusiste es un ejemplo de no sé si la herramienta ya estaba 01:47:15

hecha, que era para 01:47:24

si lo quieres jugar en 01:47:25

móvil, que ponías en la pantalla 01:47:28

un botón 01:47:30

para jugar en móvil 01:47:31

no, en móvil 01:47:33

el típico 01:47:35

táctil que tú pones el dedo gordo 01:47:38

y lo vas moviendo y es como si fuera 01:47:40

la cruceta 01:47:42

si quisiéramos cambiar 01:47:43

ese botón, tendríamos que 01:47:46

hacerlo a partir de ahí o podríamos hacer 01:47:48

un botón desde el canvas 01:47:50

y luego meterle por programación 01:47:52

para que sea 01:47:54

un pad 01:47:55

al final tendrías que meter un botón con unos límites 01:47:57

de movimiento que vaya capturando 01:48:00

esa manipulación 01:48:02

y lo haría, lo que pasa 01:48:04

que eso tiene tela 01:48:05

entiendo, no me acuerdo muy bien 01:48:06

a dónde te referirás, pero ya en el propio 01:48:09

Asset Store, lo digo 01:48:12

porque a partir de ahí sí que puedes cambiar 01:48:14

igual la imagen o la 01:48:16

cruceta o lo que quieras a nivel visual 01:48:18

pero entiendo que te refieres a Asset Store 01:48:19

es que no me acuerdo cómo se llamaba 01:48:22

Pero había un archivo que de hecho era gratis, que era para input, yo qué sé, es que no sé cómo se iba a llamar, pero había una historia que se llamaba Mobile Input Capture, por ejemplo esto, vale, este te pago, pero los hay más baratos, hay muchos scripts que lo que te permite es meter un Canva que ya está programado para que tú puedas ir moviendo en base a unos ejes y tú ya por código vas cogiendo eso. 01:48:24

Y aquí básicamente puedes cambiar la imagen por lo que quieras, ¿vale? Pero hacerlo desde cero se puede hacer, claro, pero es muy largo. No sé en qué momento os conté eso, que seguro que fue en un saber más o algo así, pero existen, a ver, de hecho, a ver si hay alguno gratis, pero que existen este tipo de inputs. 01:48:52

A ver cuánto... No, esto no, esto no, esto no. Había uno de hecho que venía con los... Mira, de hecho aquí, si no me equivoco, en los propios Starter Assets que vienen de Unity ya te vienen crucetas y botones interactivos para móvil. Ya vendrán hasta una escena ya configurada para poder probarlo. 01:49:15

probarlo, pero bueno 01:49:35

seguramente sea más farragoso que 01:49:36

otros de los, de las crucetas 01:49:38

que te he puesto antes 01:49:41

un Swag Controller 01:49:42

mira aquí hay un 01:49:44

no, mira el joystick 01:49:46

este, vale 01:49:49

pues este ya es un joystick que está 01:49:54

pues configurado 01:49:57

para descargarlo, lo cargas 01:50:00

y ya está preparado 01:50:02

y simplemente metiéndote la jerarquía 01:50:04

y buscando de dónde está sacando estos 01:50:06

sprites, si lo cambias ya puedes 01:50:08

poner la imagen que quieras. 01:50:10

¿Vale? Vale. 01:50:13

Así que 01:50:15

es que se puede 01:50:17

hacer, claro que se puede, pero bueno, sí, 01:50:18

es mucho jaleo. 01:50:20

Lo que puedes hacer también es, si te lo descargas, mira, este gratis 01:50:22

es meterte en el código que lo gestiona 01:50:24

y estudiártelo. Digo, 01:50:26

que a veces es hacer ingeniería 01:50:28

inversa, pero existen muchos joystick de este 01:50:30

tipo porque es como 01:50:32

si quisieras hacer los axis 01:50:33

desde cero. Pues es que, claro, ya están 01:50:36

prehechos normalmente 01:50:38

vale, perfecto 01:50:39

vale, gracias 01:50:42

pues 01:50:43

algo más 01:50:44

la tarea si no me equivoco es para 01:50:47

la semana que viene, final de semana que viene 01:50:49

todavía queda tiempo 01:50:52

y bueno, más o menos 01:50:53

hemos visto un poco como se hace todo 01:50:54

es sentarse y hacerlo poquillo a poquillo 01:50:57

y como siempre pegarse un poco 01:50:59

con el proyecto, pero eso 01:51:02

en este tipo de 01:51:04

proyectos de código pasa siempre, digo que 01:51:06

Sacarlo a la primera es complicado. Así que si no hay más dudas, pues vamos a ir dejándolo, ¿vale? 01:51:08

Pues muchas gracias por asistir y hasta la próxima, ¿vale? Venga, muchas gracias. Hasta luego. 01:51:15

Tutoría 8 - DEIM - UT4 y 5 - Curso 24·25 - 25 Febrero - Contenido educativo

Del mismo autor…

Tutorial1ºDiver6ºPrácticaGimp

FELICITACIÓN NAVIDAD AM 2025

CAUSAS EXTINCIÓN ANIMALES

Vídeo resumen "La evolución de los seres vivos" 4º ESO, Biología

Vídeo resumen "Alteraciones genéticas" 4º ESO, Biología

Vídeo resumen "La célula" 4º ESO, Biología

Miniconferencia Cloe