Tutoría UT4 - DEIM - Curso 25·26 | Mediateca de EducaMadrid

Vale, mira, por ir más al grano, hay dos menús, bueno, hay que hacer tres, incluimos el HUD, 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, que es una imagen con tres botones. 00:00:01

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

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

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

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

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

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:00:49

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:01:14

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:01:34

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:01:50

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:02:06

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, pues genera este rectangulillo blanco, 00:02:18

que según como esté configurada 00:02:30

con las opciones del canvas scaler 00:02:33

del canvas en general 00:02:35

el render mode, vienen descritos 00:02:36

en el tema también 00:02:39

si acaso volvemos a esto 00:02:40

pero dentro de este canvas 00:02:42

es donde vamos a ir incorporando los distintos elementos 00:02:44

de nuestras interfaces 00:02:47

para que se vea 00:02:48

el 00:02:51

elemento de user interface 00:02:52

en un nivel siempre tiene que haber un canvas 00:02:55

mínimo, puede haber más de uno 00:02:57

que vaya agrupando distintos 00:02:58

distintas interfaces, sí que es lógico 00:03:00

lo mejor realmente usar solo uno 00:03:04

que agrupe todo, porque así todos los elementos 00:03:07

se escalarán siguiendo una misma lógica, un mismo criterio 00:03:10

que si hacemos varios ya puede haber ciertos conflictos 00:03:13

y también tiene que haber otro elemento que es este 00:03:17

que también lo genera automáticamente cuando incorporamos un elemento de UI 00:03:19

en el nivel, en la escena 00:03:22

este Event System que básicamente sirve para indicar 00:03:25

así rápido, indicar 00:03:29

si estamos jugando con 00:03:30

un teclado 00:03:32

cuál es el elemento que sale 00:03:34

seleccionado ya por defecto 00:03:36

y también para indicar las teclas 00:03:38

de navegación, ¿vale? 00:03:41

con un ratón es muy fácil 00:03:41

decir aquí, aquí, ¿vale? pero si jugamos con un 00:03:43

gamepad o con un 00:03:45

bueno, pues con otro 00:03:47

tipo de dispositivo que no es tan 00:03:49

versátil, ¿no? tan 00:03:51

apuntable, no sé si existe esa 00:03:52

palabra, pero espero que me entendáis 00:03:55

Pues hay que decir qué teclas, ¿vale? Y veis que ahora yo estoy dando a la flecha arriba y abajo de mi teclado y veis que voy pasando entre un nivel y otro. Y esto se debe a que está configurado en este input module, ¿vale? Si estáis usando el nuevo input system, hay que cargar otro. Se carga por defecto o te da una sugerencia de carga de otra forma de indicar qué inputs o qué axis, ¿vale? O qué botones o qué elemento es el que proporciona cada acción. 00:03:57

pero bueno, el Event System tiene que estar ahí 00:04:23

incluso aunque luego lo dejáramos vacío 00:04:25

en gran parte, es un elemento 00:04:27

pues que tiene que estar 00:04:29

¿vale? Luego 00:04:30

ya dentro del Canvas, como también 00:04:32

se explica en el tema y supongo que es una de las 00:04:35

cosas que estaréis tocando 00:04:38

en esta tarea, dado que se piden, bueno, pues se pueden ir 00:04:39

metiendo desde imágenes hasta 00:04:41

botones, ¿vale? 00:04:43

y campos de texto 00:04:45

sliders, etcétera 00:04:47

¿vale? Bueno, distintos elementos 00:04:49

están referidos a esta gestión de los elementos de User Interface. 00:04:51

El Canvas, yo también pienso, y suele ser un buen enfoque, 00:05:00

que cuando tengo muchos elementos dentro y tengo que ir gestionando código 00:05:05

para hacer referencia a algo de estos botones o estos inputs o imágenes, 00:05:10

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

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

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:05:37

abajo pueden tener ya lo que se conocen como eventos vale que digamos que ya hay 00:05:46

una configuración hecha en unity en ese elemento vale que dice oye pues en este 00:05:51

elemento botón como es lógico un botón por definición el botón porque sirve 00:05:57

para pulsar un botón y que ocurra algo ya hay un evento se digamos que 00:06:01

está siempre escuchando que ocurre algo en relación en este caso a que se haga 00:06:06

clic es decir que cuando se haga clic en este elemento por ejemplo en este botón 00:06:10

de play es el que está aquí ahora mismo seleccionado vale lo he colocado y al 00:06:15

final lo que se puede hacer aquí es cargar un script que tengamos y llamar 00:06:21

al método que tengamos previsto no entonces al final la forma de no 00:06:25

perderse cuando cargamos este script que dentro tiene un método vale voy a abrir 00:06:32

ese script para que veáis también que escribir para que no sea tan abstracto 00:06:36

es, yo tengo en el menú de introducción este que hay, 00:06:40

realmente lo único que hay que hacer es poner botones 00:06:46

y que esos botones, al pulsarlos, nos lleven a distintas escenas. 00:06:50

No hay comportamientos más complejos en este, en el otro menú sí los hay. 00:06:54

Y por eso probablemente es porque estáis más atascados en ese nivel. 00:06:57

Pero bueno, simplemente tener en cuenta, pues yo entonces he dicho, 00:07:01

vale, este canvas voy a ponerle un script ya puesto aquí, 00:07:05

que se llama Loaded Scenes, que sirve para cargar escenas, y lo tengo aquí preparado con su namespace, su librería para la gestión de niveles, ¿vale? Esto también lo explica el tema, que esté preparado con métodos públicos, ¿vale? 00:07:09

Dos métodos públicos que veis que no se llaman en ningún tiempo de ejecución, 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 en un elemento de UI, en este caso botones para clicar. 00:07:26

Entonces yo en el canvas, que es un game object que puedo arrastrar aquí, 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í 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 tendrá este método salir, 00:07:42

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? 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, la gracia que tiene también es que podemos poner un parámetro al configurarlo, que es este parámetro que aparece aquí. 00:08:12

Entonces gracias a esto lo que podemos hacer es 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. 00:08:35

no hay ninguna crítica, como os pasaba a muchos en la tarea 3, 00:09:05

que hacíais una script para cargar cada nivel. 00:09:08

Pues script para nivel 2, que lo que hacía era cargar el 3, 00:09:11

y script para el 3, para cargar el 4. 00:09:15

En el tema se habla de que las escenas se pueden cargar poniendo un número, 00:09:18

que es el número del índice que acabamos de hablar en el build settings, 00:09:22

o también, bueno, más complejo de adivinar, que es poner el nombre, 00:09:26

por ejemplo, de esa escena. 00:09:30

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:09:32

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 índex 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. 00:09:52

¿Vale? Entonces es importante tener en cuenta que los comportamientos de los métodos interactivos, y voy rápidamente, no lo quiero guardar, ¿vale? Lo que cambia por si hay que tocar 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, este es otro de los elementos que se pueden agregar, ¿vale? 00:10:13

Este, por ejemplo, o el Legacy, el Input Fill, ¿vale? 00:10:42

Es ese campo de texto que se puede introducir. 00:10:46

Aquí no es al hacer clic cuando sucede la acción. 00:10:49

Aquí es cuando cada vez que vayamos cambiando un valor, 00:10:51

es decir, vayamos tocando una tecla, 00:10:54

pues yo aquí he preparado otro canvas con otro script diferente 00:10:57

adaptado a qué estamos buscando en este menú, ¿vale? 00:11:00

Pues que se va a ocupar de un texto, de un slider, 00:11:05

y también de los textos que va a ir mostrando aquí de dificultad. 00:11:08

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í, ¿vale? 00:11:12

Los textos, estos input fields, no solo pueden lanzar eventos cuando estamos cambiando los valores. 00:11:27

Puede ser que sea cuando terminemos de editar y salgamos. 00:11:39

En ese caso, habría que añadir aquí el canvas, en este caso, que es el objeto que tiene el método, 00:11:43

y aquí poner el método que nos interesaba. 00:11:48

DayDestines, este canvas, sería el de ConfigMenu. 00:11:51

Yo busco aquí que he preparado funciones en ConfigMenu y aquí tendré que ver, por ejemplo, UpdateInput y UpdateSlider, que son los métodos públicos que he generado yo en este. 00:11:57

Yo 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:12:12

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

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

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:12:47

Pues 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:12:54

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

Simplemente algo que es importante 00:13:19

Que también cuando os hayáis puesto 00:13:23

No quiero guardar 00:13:26

Cuando os hayáis puesto a trastear 00:13:27

Con crear el canvas, poner la imagen de fondo, etc 00:13:29

Es que a veces no es del todo intuitivo 00:13:32

Cómo surge esto 00:13:37

En el canvas, en cualquiera 00:13:38

Al final está 00:13:40

Cómo se ve este canvas 00:13:41

Pues si es una sobreposición a lo que haya en la escena 00:13:42

Que sea un poco independiente de la cámara 00:13:45

y que básicamente se ponga por encima, que se ubique en el espacio como un elemento 3D 00:13:48

o que tenga en cuenta una cámara y ya el plano focal también, ¿vale? 00:13:52

Pero más que eso, este canvas scaler en relación con que en la pantalla game, ¿vale? 00:13:56

Y esta es la forma de testear si están escalándose bien o no los elementos que tengamos en juego 00:14:03

de User Interface, es que nosotros, por defecto, en la pantalla de juego, 00:14:12

en donde estamos simulando el juego, vais a ver que aquí hay distintos aspect ratios. 00:14:18

Pero nosotros aquí podemos definir cuál es el tamaño de ese juego, 00:14:23

el tamaño final en el que estamos pensando que se está haciendo nuestro juego. 00:14:28

Vosotros tened en cuenta, y por eso sucede que yo cuando voy arrastrando, 00:14:32

haciendo más grande y más pequeña esta pantalla 00:14:36

pues salen estos rebordes 00:14:38

que son el fondo 00:14:41

este 00:14:43

Skybox 00:14:44

este HDR que envuelve 00:14:45

pero nosotros 00:14:48

cuando juguemos no vamos a querer 00:14:51

que se vean esos fondos, queremos que se adapte 00:14:52

a las medidas 00:14:55

si nosotros sabemos que nuestro juego 00:14:56

se va a reproducir en dispositivos 00:14:59

que son de 1920 00:15:01

por 1080 píxeles o full HD 00:15:02

nosotros podemos definirlo ahí 00:15:05

pero tener en cuenta una cosa 00:15:07

y esto es algo que a veces 00:15:09

no tenemos en cuenta pero cuando hablamos 00:15:10

de un píxel, realmente un píxel es 00:15:13

un cuadrado con información de brillo 00:15:15

un píxel de una pantalla 00:15:18

pero no tiene una medida establecida 00:15:19

habrá móviles 00:15:21

de hecho normalmente los móviles 00:15:24

con los que contamos son una pantalla 00:15:25

pequeñita de 1920 00:15:27

por 1080 si lo ponemos en 00:15:30

horizontal y es 00:15:31

la misma resolución, las mismas dimensiones en píxeles que a lo mejor el monitor de ordenador, 00:15:33

que es cinco veces más grande, que también es 1920x1080 píxeles. 00:15:38

Por eso es importante tener en cuenta que se pueden hacer contenidos de user interface 00:15:43

con un tamaño de píxel lo que se llama constante, que es decir, en relación a las dimensiones 00:15:48

que tenga la pantalla que sea, que cada unidad de medida que tenga nuestro proyecto, que sean 100 píxeles. 00:15:57

Entonces están, y luego aquí hay una que incluso lo que hacemos es que decimos, no, la pantalla es que va a tener 00:16:12

estas medidas físicas, reales, y con una densidad de píxel X, que es esto del DPI. 00:16:18

¿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:16:24

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:16:44

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

Y aquí es donde podemos decir, vale, que no sean unas medidas concretas, que no sean 1920 píxeles por 1080 píxeles, 00:17:10

que el dispositivo le está diciendo que tiene estas dimensiones, sino que tenga un aspect ratio, vale, un alto y un ancho siempre de 1920 por 1080. 00:17:17

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:17:24

pero esto a lo que quiero llegar es que se habla luego en los elementos en los propios elementos 00:17:39

de que existe esto de los puntos de los puntos de anclaje vale y esto tiene sentido cuando ponemos 00:17:45

unas dimensiones que están establecidas si lo que hacemos es que se escale con el tamaño de 00:17:53

la pantalla veis que lo que va a hacer es oye tómate esta proporción de aspecto este aspecto 00:17:59

de 16 novenos y si la pantalla fuera más grande o más pequeña mientras tenga esa proporción pues 00:18:06

no va a haber problema porque se escalará todo uniformemente que ocurre que si tenemos una 00:18:14

pantalla muy pequeña también puede suceder que de pronto pues los botones se hacen muy pequeños y 00:18:19

si queremos que aunque la pantalla la resolución fuera pequeña los botones como los vamos a hacer 00:18:25

pulsar si hicieron más grandes ahí es cuando nos puede venir bien jugar con que lo que tome es vale 00:18:30

en relación a los píxeles que tenga esa pantalla pues oye yo quiero que este elemento vale y aquí 00:18:36

es donde seguirán ajustando la proporción de cuántos píxeles tiene cada bueno esto me está 00:18:42

saliendo bueno voy a poner un poquito más grande vale es donde yo indico como quiero que esto se 00:18:48

escale o no, ¿vale? Que es donde habrá que ir diciéndole que esto tenga una proporción 00:18:54

X y este botón, por ejemplo, de jugar, que lo vemos aquí con estas anclas, se vaya escalando 00:19:00

a medida que esa pantalla detecte que es más grande o no, ¿vale? Esto ya, a ver, lo voy 00:19:09

a hacer con el botón de jugar, pues si vamos definiendo aquí estos puntos de anclaje, 00:19:14

¿vale? Cuando vayamos haciendo más grande y más pequeña la pantalla, veis que sí 00:19:20

que se queda en un sitio y con unas proporciones a lo que quiero llegar vale que esto sí que es 00:19:23

un poco prueba y error porque en el momento es un poco confuso entenderlo claramente en plan 00:19:28

cuando sucede algo cuando sucede no es que a no ser que tengamos muy claro que va a tener unas 00:19:33

medidas muy concretas normalmente lo que nos interesa es que toda la pantalla se haga más 00:19:39

o menos grande vale porque además por lo general eso tenemos ya proporciones muy estandarizadas 00:19:43

pero otro elemento importante 00:19:50

que a veces sucede también cuando corrijo 00:19:53

vuestras tareas, también normal, es que cuando 00:19:55

ponemos FreeASP es básicamente que nos llene 00:19:57

con contenido pues todo el 00:19:59

cuadro que tengamos, todo el visor que tengamos 00:20:01

de la pantalla game, nada se adapta 00:20:03

se adapta al ancho y al 00:20:05

y al alto 00:20:07

pues para que se ajuste 00:20:09

en relación a lo que sería ese 16 novenos 00:20:11

en este caso que está ahí establecido 00:20:13

¿vale? y de hecho si os fijáis 00:20:15

por eso sale esta caja 00:20:18

que sobresale, porque al final se está todo el rato ajustando para que coja o el ancho o, atención, el alto, y veis que ahora coge la otra dimensión de esta caja de referencia, ¿vale? 00:20:19

Para que se adapte en todo momento. Pero lo suyo, ¿vale? Y aquí siempre está todo a escala 1, lo suyo en ocasiones, cuando queremos ver que algo tiene unas medidas concretas 00:20:31

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:20:42

Porque aquí, con respecto a mi monitor, sí que se está viendo pequeño. Mi monitor podría enseñarlo, en ese aspecto que tenemos, y dado que mi monitor le está diciendo al sistema que es 1920 píxeles por 1080, en realidad aquí sabe que se está haciendo más pequeño. 00:20:58

Pero en realidad esto, como se vería si lo viéramos a tamaño completo, es esto. Esta es la medida real que va a tener en un dispositivo con el que estoy viendo. 00:21:14

Entonces, que a veces pueden 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:21:23

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:21:46

Es verdad que para verlo bien, 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:22:02

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:22:25

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:22:40

Pero bueno, está haciendo una adaptación con este Scale with Screen Size que sí que en realidad es relativo. Pero bueno, que sepáis que eso, que si estáis trabajando para pantallas concretas o dimensiones de píxel concretas, esto es muy importante. 00:23:01

vale, me pone una pregunta 00:23:15

algunas fuentes que he cargado en Unity 00:23:17

no me funcionan, aparecen pero no se aplican 00:23:19

es muy raro, vale, necesito 00:23:22

que me contestes si estás 00:23:23

usando en tu proyecto el 00:23:25

TextMeshPro o el TextLegacy 00:23:27

es decir, si has instalado el 00:23:29

TextMeshPro, vale, el TextMeshPro 00:23:31

si no me equivoco 00:23:33

lo voy a buscar un segundo, os dejé un tutorial 00:23:35

mira 00:23:37

aquí, si vas al 00:23:39

apartado 3.1.1 00:23:41

hay aquí un método 00:23:43

imagino que es esto 00:23:46

de cómo convertir una fuente de texto 00:23:48

una tipografía para que funcione en TestMeshPro 00:23:50

si no me equivoco 00:23:52

tendría que verlo 00:23:53

pero si no me equivoco 00:23:56

cuando instalas el TestMeshPro 00:23:58

yo ya lo he instalado 00:23:59

como pone en el tema 00:24:00

hay un menú aquí 00:24:01

que se llama FontAssetCreator 00:24:05

tendría que importar esto 00:24:07

que no lo hice 00:24:09

lo importo 00:24:09

Dame un segundo de cargue y tal, ¿vale? 00:24:11

Bueno, y cuando, bueno, perdona, que se me ha desconfigurado un poco la pantalla. 00:24:15

Eso, cuando instaláis todo lo necesario para ir funcionando con TestMesh Pro, 00:24:21

aparece esta opción del asset creator y aquí puedes buscar esa tipografía, ¿vale? 00:24:26

Que tengas, la metes y, bueno, hay distintas opciones que en principio no habría que tocar mucho 00:24:32

porque yo creo que por defecto la va a hacer bien 00:24:37

y es generate font 00:24:39

atlas, cuando le das aquí 00:24:41

hace un proceso que básicamente 00:24:43

lo que hace es guardar esa tipografía 00:24:45

no sé muy bien donde me la guarda 00:24:47

ahora mismo 00:24:49

pero básicamente en algún punto 00:24:50

del nivel, o igual 00:24:53

hay que guardarlo y ahora no me acuerdo 00:24:55

aquí en fonts, vale 00:24:57

me ha creado esta tipografía 00:24:59

¿vale? y esta tipografía 00:25:01

ahora sí que la puedo meter 00:25:03

pues en donde haya 00:25:05

un campo de texto 00:25:07

pues se puede meter este legacy 00:25:08

¿vale? y en principio 00:25:11

bueno es que yo no estoy 00:25:13

usando el testmesh pro ¿vale? ese es el problema 00:25:15

que cuando 00:25:17

no es testmesh pro 00:25:19

con arrastrar la tipografía a los assets 00:25:20

¿vale? ya se carga, ya se puede usar 00:25:23

pero claro testmesh pro como tiene 00:25:25

más opciones de sombrearla, de ponerle 00:25:27

rebordillos, hacer ese tipo 00:25:29

de cosas, hay que hacer esta operación de 00:25:31

convertirla ¿vale? con el 00:25:33

Fondo Asset Creator y ya una vez está creado, ya sí la puedes usar en un TestMesh Pro. 00:25:35

De hecho, pongo uno aquí, aunque sea de prueba. 00:25:40

Voy a poner aquí y voy a decirle que sea Liberation Sans. 00:25:44

Esta tipografía aquí, le digo tipografía aquí. 00:25:49

Y ya me la está cogiendo, por lo que veo. 00:25:54

A ver, la que acabo de crear es esta, si no me equivoco. 00:25:57

Y lo que voy a hacer es poner hola y lo voy a poner más grande y que esté donde tiene que estar, que es... 00:26:04

Esto, la cosa es que está muy... Vale, importante, porque no se está viendo, porque lo he creado fuera del Canva, importante también, que si no, no se va a ver en la vida. 00:26:17

y te te espera pero nada pero no se está viendo también por qué 00:26:34

vale porque se está desbordando probablemente 00:26:50

está ahí porque no se ve lo primero voy a borrar esto voy a 00:27:01

hacer el canvas cuál no os recomiendo usar está detrás 00:27:06

del fondo ahora lo vemos pero no pero no está detrás del fondo bueno ahora lo probamos si lo 00:27:12

dice será ahora si está no sea crearlo no le crea bien ahí está vale ahora sí que es importante 00:27:20

cuando creéis un elemento de yu hay sino si ya está el canvas pues darle al canvas que va a 00:27:28

quitar problemas si yo antes cuando lo arrastraba en principio estaba ya abajo del todo bueno esto 00:27:33

lo que dice el compañero, el orden 00:27:39

de renderizado, cuando hay elementos 00:27:41

que ocupan todo, como este fondo 00:27:44

va de abajo a arriba, es decir 00:27:45

lo de abajo se ve por encima 00:27:47

por ejemplo 00:27:49

si yo quito aquí zoom 00:27:50

y pongo 00:27:53

voy a hacer más grande 00:27:54

la caja, si lo pongo 00:27:57

encima, imagino que lo veis 00:27:59

del botón, al estar 00:28:01

por debajo de la jerarquía se ve por delante 00:28:03

si lo pongo por detrás, se ve por detrás 00:28:05

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

pero vaya, ¿tipografía 00:28:10

que usar? pues 00:28:12

la que queráis 00:28:13

la verdad es que no tengo 00:28:15

ninguna pensada 00:28:17

si queréis 00:28:18

esta de Legacy Runtime, si no me equivoco 00:28:21

viene con el propio sistema 00:28:23

entonces 00:28:25

pues esa misma 00:28:27

no recuerdo 00:28:29

si esta la descargué o 00:28:31

la bajé de por ahí, pero yo creo que esta 00:28:33

está ya directamente con Unity. Pues esa, por ejemplo, podría estar bien. Pero la que veáis, 00:28:35

pues básicamente que se vea bien. Que sea... Hombre, normalmente las gordotas, las que son 00:28:45

así más gruesas, que tienen así... Y lo que se llama un compress, que es que son más verticales 00:28:51

a veces que horizontales, que es lo que pasa aquí, que son bastante verticales, pues funcionan bien. 00:28:57

no lo sé, si queréis 00:29:02

tipografías hay una web 00:29:04

que supongo que conocéis de RPMI 00:29:06

que se llama 00:29:08

bueno 00:29:09

Dafont por supuesto que tiene muchísimas 00:29:12

no siempre tienen que ser de muchísima calidad 00:29:14

pero hay muchísimas 00:29:16

y muchas gratis, os lo ponen aquí 00:29:18

y muchas categorías, luego hay otra 00:29:20

que son como más de diseñadores 00:29:22

establecidos que es esta de Lost Type 00:29:24

que también tiene muchas 00:29:26

tipografías y 00:29:28

en algunos casos son gratuitas 00:29:30

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. Pues, aquí, si pone que es un paga lo que quieras, pues, aunque no sea lo más adecuado probablemente, si ponéis cero la podéis descartar. 00:29:32

El compañero dice, los assets de Unity, hay algunas bonitas también en Asset Store. Pues también puede haber, aunque yo, ¿verdad? Que no suelo buscarlas aquí. También hay a veces fuentes que se pueden usar. Vale, entonces, bueno, pues la que veáis más adecuada. 00:29:54

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

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

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

No me preocupa de poner otra más compleja 00:30:34

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 00:30:38

Bueno, luego hablaremos de esto, que es que si carga la primera escena, yo he hecho que las vidas se recarguen con tres. Y uso este GameManager, ahora vemos, pero que básicamente es el script, lo tengo aquí, otro script que se llama GameManager, que la gracia que tiene es que todo lo que tiene dentro son variables estáticas. 00:30:44

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 de cómo cargar un test input que se pone en un menú para que salga en el hat del otro, que es que habrá que guardarlo en una variable estática pública, siempre, de tipo string, que es username. 00:31:02

Y en esta variable estática, que va almacenando independientemente de la escena, digamos que está por un nivel superior al resto de scripts, a nivel de que siempre está accesible, aquí es donde guardaremos este nombre. 00:31:26

De hecho ahora hablo del Game Manager 00:31:41

Si me decís que no tenéis 00:31:44

Dudas de este primero 00:31:46

Antes incluso que pasara el de configuración 00:31:48

Hacemos una 00:31:50

Una visita a esto 00:31:51

Esto, de este nivel alguna duda 00:31:53

Paso a la siguiente 00:31:56

Vale, dudas 00:31:59

Me dicen 00:32:04

Podéis hablar por micrófono si es más rápido 00:32:05

Pero bueno, o si me lo escribís 00:32:09

O si no voy avanzando y luego vuelvo allá 00:32:10

Digo porque es que si no a lo mejor tardáis 00:32:13

Sí, hola 00:32:15

A ver, es una tontería 00:32:16

por ejemplo, con el ratón pasas por jugar 00:32:19

configuración, salir 00:32:21

¿lo podemos también hacer con 00:32:23

teclado, ratón y mando? 00:32:25

¿Te refieres a la navegación? 00:32:28

Sí 00:32:31

Sí, eso es lo que 00:32:31

por lo que existe este Event System 00:32:32

y está este 00:32:34

el primero que está seleccionado 00:32:35

que yo he puesto el botón 00:32:39

play, ¿vale? para que aparezca y por eso 00:32:40

de hecho cuando yo doy a reproducir 00:32:43

vas a ver, yo no toco nada 00:32:45

bueno, está esto de maximizado, ves que jugar 00:32:46

está seleccionado, y yo ahora 00:32:48

voy a mover las flechas del ratón 00:32:51

de, uy, del ratón, las flechas 00:32:53

del teclado, no estoy tocando el ratón, puedo ir 00:32:55

hacia arriba, hacia abajo, y luego 00:32:57

le doy a intro, y juego 00:32:59

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

se, y voy a quitar esto de 00:33:03

maximizar para que se vea todo 00:33:05

claro, tú con el event system dices 00:33:07

primero, cuál de los elementos 00:33:11

es el que aparece seleccionado 00:33:13

He arrastrado este button play, lo he arrastrado y lo he dejado ahí. Y aquí están los ejes, que son los axis, se llaman igual que los axis, que ya conocemos, pero vamos a conocerlos otra vez, de los project settings y el input manager. 00:33:14

Pues con las teclas que tengamos aquí de horizontal hará movimiento horizontal, vertical, submit, que es el de acceder y el de cancelar, que es para si hay alguna acción que se deshabilita una vez ya está hecha. 00:33:30

Se hace con las teclas que pongamos aquí. Por ejemplo, el vertical, que es el de las flechas arriba y abajo, también debería, y lo voy a hacer ahora mismo, con la S y la W navegar. 00:33:45

¿Ves? Con S y W navego. Esto se da, creo que lo pone también en el tema, cuando tenéis botones, ¿vale? Y tienen que ser elementos que se puedan seleccionar. Y básicamente serán los elementos que dentro de sus opciones tengan esto de Interactable. 00:33:56

Unos solo botones, si no me equivoco, luego lo vemos, en los input fields también habrá algo relacionado con el interactable, los sliders también, ¿vale? Pero esto se define en esta navegación, está la automática, que lo que hace es ver dónde hay distintos elementos interactuables en la escena, ¿vale? 00:34:12

Y hace una navegación, digamos, automática que cuando damos a este botón de visualizar, ¿vale? Y nuevamente hay que ir a la escena, no al juego, ¿vale? Veis que salen esas flechitas que pone arriba y abajo porque ha detectado que para pasar de este a este, pues lo lógico es una dirección vertical. 00:34:33

si yo por ejemplo moviera esta flecha 00:34:50

veis que ya empieza a complicarse 00:34:53

si estando en jugar doy a la 00:34:54

y ves que sale de la derecha 00:34:57

voy aquí a config 00:34:59

y ahora el primero que va a salir 00:35:00

seleccionado es jugar 00:35:03

es decir, si doy ahora abajo 00:35:04

espero que veáis la flecha 00:35:07

porque igual lo veis muy pequeñillo 00:35:10

me acerco aquí 00:35:11

cuando yo de 00:35:12

cuando yo de abajo va a ir a salir 00:35:14

ahora, ¿vale? 00:35:17

y cuando de arriba va a config 00:35:19

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:35:20

Eso lo hacen 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:35:37

Entonces aquí lo que habrá que ir poniendo, aunque esta opción no la recomiendo, es que podemos ir arrastrando aquí, al darle abajo en este botón de play, quiero que vaya al botón de config. 00:35:51

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:36:03

pero bueno, lo suyo es poner que sea automático 00:36:17

y si ponéis horizontal y vertical 00:36:21

con esto podéis restringir que a lo mejor 00:36:24

todas las interacciones tengan que ser de manera horizontal 00:36:26

y no se admitan las verticales 00:36:31

pero bueno, esto habría que irlo haciendo en todos los botones 00:36:33

cada botón tendría sus combinaciones 00:36:36

lo más fácil, el automático y detecta 00:36:38

incluso quitar el explícito 00:36:40

y aquí detecta según visualmente 00:36:42

cómo se distribuyen los elementos de la escena 00:36:45

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? 00:36:47

Entiendo que te he contestado la duda. 00:36:57

Sí, gracias. 00:37:00

Vale, pues vamos, voy a explicar qué es el Game Manager. 00:37:03

Hay una cosa que pone en el tema, que es verdad que en esta versión de Unity vi que no sucede y lo han ido quitando, debe ser, en las últimas, 00:37:07

que es que cuando creas un script llamado 00:37:14

GameManager, antes aparecía una tuerquita 00:37:17

y ya no, bueno, era solo una 00:37:18

ayuda visual para tener claro 00:37:21

cuál era el GameManager 00:37:23

y esa de la tuerquita, bueno, venía bien 00:37:24

porque era más visual 00:37:27

significa que cuando a un script 00:37:28

lo llamamos GameManager, pues algo 00:37:31

tiene de especial para que le pongan otro 00:37:33

icono 00:37:35

propio 00:37:36

y esto es porque 00:37:38

básicamente por convención también 00:37:40

suele haber un script en el juego que se llama GameManager 00:37:42

en el que se van estableciendo 00:37:47

puede haber más de uno realmente con otros nombres 00:37:49

pero bueno, que GameManager es un script 00:37:52

en el que digamos todas las mecánicas 00:37:56

bueno, la palabra no es mecánicas 00:37:59

todas las variables 00:38:00

o los elementos de programación que vayan a ser recurrentes 00:38:04

en todo el juego, como sucede aquí, pues que sea 00:38:08

entre diferentes niveles y no sea solo 00:38:10

de un nivel, pues es este gestor de juego 00:38:12

y es donde vamos almacenando 00:38:14

información para desde este script 00:38:16

irla gestionando entre distintos niveles 00:38:18

como he dicho antes, para que esté 00:38:20

en un nivel superior al resto 00:38:22

de scripts que operan 00:38:24

en el componente que 00:38:25

los asignes 00:38:28

y que esté siempre 00:38:30

accesible o pueda hacer operaciones 00:38:32

de más alcance 00:38:34

en este caso 00:38:36

y es un ejemplo 00:38:38

importante a tener en cuenta 00:38:40

de para qué serviría 00:38:43

esta lógica, que es este 00:38:45

el de crear funciones estáticas 00:38:47

perdón, variables estáticas 00:38:49

cuando creamos una variable 00:38:52

estática, y lo mismo 00:38:54

por defecto 00:38:55

una estática para poder acceder 00:38:57

desde otros scripts y poder modificarlo 00:38:59

y acceder a estas variables 00:39:02

pues habría que hacerla pública 00:39:03

luego al declarar la variable 00:39:05

pues ponemos el tipo de variable 00:39:07

que es, un int, un string, un flow 00:39:09

lo que sea, podría ser lo que sea 00:39:11

y luego el nombre que tiene esta 00:39:13

variable, hasta aquí como siempre 00:39:15

lo único que ha cambiado es que 00:39:18

siendo pública, aparte 00:39:19

digamos que permanece, por eso de estática 00:39:21

permanece incluso cuando se 00:39:23

para un nivel 00:39:25

¿vale? y se recarga 00:39:28

en otro nivel otros scripts 00:39:29

esto, como 00:39:31

tenemos una clase 00:39:33

llamada GameManager, que es pública 00:39:36

y una variable que es pública 00:39:37

esto como ya vimos en su momento 00:39:39

en otros scripts, siempre ya 00:39:42

desde cualquier otro punto de los scripts 00:39:44

abro este por ejemplo 00:39:47

a ver si quiere que 00:39:48

a ver, espera, voy a ir agrupando 00:39:49

porque si no tengo aquí un montón de ventanas 00:39:52

y no es lo que quiero 00:39:54

en este por ejemplo, bueno, veis 00:39:55

que aquí lo que estoy haciendo 00:39:58

tengo un 00:40:00

un static que se llama lives 00:40:02

y yo aquí 00:40:04

sin haber creado ningún tipo de variable 00:40:06

antes, puedo hacer directamente 00:40:08

a la variable lives, simplemente poniendo 00:40:10

¿vale? fijaos que tengo otra 00:40:12

así rápidamente que se llama username 00:40:14

que ahí es donde vamos a almacenar el nombre del jugador 00:40:15

por cierto, ¿vale? pues si yo aquí 00:40:18

quisiera que 00:40:20

¿vale? el nombre del jugador 00:40:21

cuando cargara la escena 1 00:40:23

¿vale? fuera Pepito 00:40:25

¿vale? independientemente de 00:40:27

de lo que haya 00:40:29

puesto en un input field o como lo hayamos 00:40:31

asignado, yo puedo aquí decir 00:40:34

¿vale? pues que el username sea 00:40:35

Pepito, ¿vale? Como es un string 00:40:37

Pues habrá que ponerlo como un string 00:40:39

¿Vale? Es verdad que hay que acordarse 00:40:42

De qué tipo de variable es 00:40:43

O bueno, ponerte encima y veis que dice 00:40:45

StaticString, ¿vale? Pero veis que no da error 00:40:47

Yo puedo acceder a 00:40:50

Variable estática, a la clase 00:40:51

Y a una variable estática 00:40:53

Sin tener que capturarla de ningún lado 00:40:54

¿Vale? Tengo aquí la dificultad, las vidas 00:40:57

¿Cuál más había puesto? 00:40:59

Ah, bueno, y el username que ya lo he puesto 00:41:01

Pero aquí está, username 00:41:03

Ahí está, ¿vale? GameManagerUserName. Y eso es lo bueno que podemos hacer desde cualquier momento. Voy a guardar esto y ahora cuando cargue el nivel, al darle a jugar, vais a ver que pone ya Pepito, porque yo tenía ya establecido que pusiera lo que esté guardado en esa variable GameManager.UserName, que es un string que lo muestra aquí. 00:41:05

entonces 00:41:30

básicamente hay que tener la lógica 00:41:32

en este momento, ¿vale? 00:41:36

de que va a haber un script en el que vamos a 00:41:37

poder ir guardando 00:41:40

desde distintos scripts o momentos del juego 00:41:41

variables para que estén ahí almacenadas 00:41:44

y poder recuperarlas 00:41:46

¿vale? entiendo que esto además 00:41:48

es una liberación, también hay que ser cauteloso 00:41:50

con qué se usa y qué nombre se ponen 00:41:52

para que no haya conflictos con 00:41:54

variables que hay en los propios scripts 00:41:56

pero en los otros scripts ya 00:41:58

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:42:00

Entonces, voy a ir al menú de configuración. No guardo porque no quiero los cambios. Aquí en este canvas, voy a ver si me habéis escrito algo. 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:42:14

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:42:38

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

El input, al final cuando creamos un input 00:43:02

Y atención, esto es lo que pone 00:43:04

Se pueden crear inputs con el texto antiguo, el legacy 00:43:06

Que se llamará luego por código de una forma 00:43:10

Que es el que de hecho he usado yo 00:43:13

Si voy a un script que luego vamos a ver 00:43:15

Pues tengo una variable de tipo texto 00:43:19

Que no es lo mismo que lo que pone 00:43:22

que si aquí cargamos el TextMeshPro 00:43:25

esta librería, va a haber otra 00:43:27

que en realidad el funcionamiento 00:43:29

es igual, solo que tiene más opciones 00:43:31

podemos hacer el TextMeshPro 00:43:33

Ugi 00:43:35

y voy a poner 00:43:38

texto 00:43:39

TMPro, vale 00:43:40

la única diferencia que hay entre estos dos 00:43:43

es que cada uno 00:43:45

hace referencia a un tipo de componente 00:43:47

cuando yo tengo un text 00:43:49

Legacy, aquí pone text 00:43:51

ya está 00:43:54

Si yo tengo un TestMeshPro, voy a crear uno aquí rápido, un elemento que tenga TestMeshPro, el componente, simplemente el texto. Se va a llamar TestMeshPro. Cada 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 es esta. 00:43:54

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. Esto lo pone en el tema, pero por si hubiera alguna duda, dicho queda. 00:44:17

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:44:33

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:44:59

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:45:14

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

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:45:35

Y que salimos, etc. Véis que se oscurece, etc. Que eso está definido en estos colores que tiene aquí o se puede poner incluso alguna animación. 00:45:45

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:45:57

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:46:14

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:46:34

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:46:50

que luego ya cuando tengamos el hat 00:47:13

pues también lo que va a hacer es 00:47:16

poner el username text 00:47:17

pues el texto que hayamos guardado ahí 00:47:19

¿sí? 00:47:21

entonces, a ver, me pongo aquí 00:47:23

vuestra pantallita por si me ponéis algo, vale 00:47:26

sigo, y esto no sé 00:47:27

por qué 00:47:30

sí, me pregunta alguien 00:47:30

adelante 00:47:34

hola 00:47:34

justamente la parte 00:47:36

del if y el else 00:47:40

del username 00:47:41

podríamos poner que si 00:47:42

no pones ningún nombre 00:47:45

te ponga como un name 00:47:47

o no name 00:47:49

de forma genérica 00:47:50

me va a hablar de esto, ¿no? 00:47:52

aquí ya está eso, dice 00:47:54

si la variable estática 00:47:57

está vacía, es decir, nunca se ha introducido nada 00:47:59

porque por defecto 00:48:01

cuando arrancamos el juego está así 00:48:03

y por tanto está vacía, hasta que guardemos 00:48:05

algo, si está vacía pone 00:48:07

player desconocido 00:48:09

este es el texto que pone si no ponemos nada 00:48:11

ah, vale 00:48:13

no está vacía, es decir, se ha introducido ya algo 00:48:14

el username va a ser 00:48:17

player, como siempre va a poner 00:48:19

esa coletilla de player, más 00:48:21

y después, dejamos un espacio 00:48:23

el nombre que se ha guardado en esa 00:48:25

variable estática 00:48:27

del nombre, que esa variable 00:48:29

estática solo se rellenará cuando escribamos 00:48:31

algo aquí, y se va a rellenar 00:48:33

además, porque 00:48:35

lo hemos puesto aquí, ¿vale? 00:48:37

es decir, cuando 00:48:39

a ver, esto ya empieza a ser un poco jaleo 00:48:40

de ir viendo en qué parte pongo 00:48:43

cosas, no sé 00:48:45

y es de lo que se trata, simplemente 00:48:47

que sepáis que aparte de lo que es el funcionamiento 00:48:49

del juego si estáis empleando, veis que 00:48:51

yo aquí en scripts, tengo los 00:48:53

scripts del juego de la tarea 3 00:48:55

que podéis usar la tarea 3 00:48:57

o lo que queráis, que tenga una cierta lógica 00:48:59

de que al dar a play 00:49:01

haya vidas y cuando muera vuelvas 00:49:03

a la pantalla de inicio 00:49:05

que me da igual que sea una bola 00:49:06

o sea otra mecánica, por si no hicisteis la tarea 3. 00:49:09

Pero realmente de User Interface solo hay cuatro scripts. 00:49:14

Y uno de ellos es el de cargar escena, que ya hemos visto, 00:49:18

que es simplemente preparar para los botones ese script. 00:49:21

El de Game Manager, como hemos visto, 00:49:25

es solo tener preparadas en un punto superior variables 00:49:27

que nosotros podamos rellenar con cosas. 00:49:34

Y luego tenemos este, que es el que tiene chicha y ahora lo vamos viendo, el que vamos a asociar este config menu al canvas para ir gestionando todo lo que tenemos aquí, todos estos inputs. 00:49:36

Aquí he preparado, como sería el Icefield 00:49:53

Varios elementos 00:49:55

¿Vale? Y luego hay otro que es el 00:49:57

Hat Manager, que es el del hat 00:49:59

Cuando jugamos, que tiene los corazoncillos 00:50:01

¿Vale? Vuelvo a... para que lo veáis 00:50:03

Este hat, y bueno 00:50:05

Antes lo que me habéis preguntado 00:50:07

Si no has puesto ningún nombre, pone por defecto 00:50:09

Player desconocido 00:50:11

Cuando pongamos algún nombre, este desconocido 00:50:12

Se ve reemplazado por lo que 00:50:15

Está guardado en el Game Manager 00:50:17

¿Vale? Y este hat tiene ese comportamiento 00:50:18

aparte de otra imagen 00:50:21

¿vale? aquí si vamos al canvas 00:50:24

este canvas pues tiene 00:50:26

esta imagen ¿vale? 00:50:28

pues que irá cargando según las vidas que nos queden 00:50:30

irá cargando una imagen 00:50:32

u otra ¿vale? en este caso 00:50:34

lo que se proporciona son varias imágenes 00:50:36

y cuando morimos vais a ver 00:50:38

que de pronto se cargará 00:50:40

vuelvo a abrir aquí, lo que se va a cargar es 00:50:41

la imagen que se llama 00:50:44

eh 00:50:46

Live 2 00:50:47

que está ya hecha para que muestre esto 00:50:50

en el tutorial de Álvaro 00:50:53

de hecho lo que hace es como ir recortando la imagen 00:50:55

cambia las dimensiones de una única imagen 00:50:57

para que se vayan viendo un corazón u otro 00:50:59

se pueden cargar imágenes distintas, recortar 00:51:00

bueno, pues ya eso es 00:51:03

pensar cómo se hace y cómo se muestra 00:51:04

pero son cuatro scripts 00:51:07

por eso digo que quiero que quede claro 00:51:09

al menos como lo he resuelto yo 00:51:11

siempre puede haber otras formas y con más 00:51:12

elementos 00:51:15

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. 00:51:17

Vale, sigo con el input. Estamos aquí. Tiene un placeholder que de este por defecto solo vamos a indicar ese mensaje de ayuda de pon algo aquí y el de texto que es el que sí queremos recoger el texto. 00:51:28

¿Vale? Recordad, ¿vale? Y me voy a este config menu. Joder, espera, porque esto siempre se me abre. Espera un segundo, que yo creo que lo puedo asociar aquí. Un segundo. Nada. Bueno, lo tengo aquí. ¿Vale? 00:51:43

Lo que se han preparado, esos serialized fields que os he enseñado antes, y mira, lo pongo aquí abierto para que lo veamos en paralelo, aquí en el canvas, ¿vale? Estos campos que tenemos aquí se corresponden con los que se han creado en este config menu, ¿no? Es el mismo menú, ¿vale? 00:51:59

Entonces, hay que pensar. Yo, dentro de lo que se pide la tarea y lo que nos interesa, lo que voy a querer es coger un texto o gestionar un texto, ¿vale? Una variable de tipo texto. Recordad que esto, las tipos de variables que se llaman con un nombre de clase, como slider, texto, etc., básicamente es el nombre que tiene el componente. 00:52:18

Se llama texto y por eso el de TestMeshPro se llama de otra forma, porque es que tiene un componente aquí que se llama texto. Entonces siempre que carguemos o hagamos un GetComponent de un componente, se va a llamar como se llama aquí. Casi siempre, no siempre, pero casi siempre. 00:52:39

Luego va a haber otro de tipo slider porque voy a querer jugar con este, esta variable que se llama slider 00:52:56

Que al final es la que tiene los valores de cuánto vale el slider, si os fijáis 00:53:07

Yo cuando muevo esto con value puedo ir gestionando desde el propio juego 00:53:11

Voy al moverlo, al ser un slider interactivo, voy, fijaos aquí, cambiando el valor de esto 00:53:19

¿Veis que cambia? Igual que yo puedo arrastrar por código, digamos, cambiar este valor por código y veis que también se ve reflejado en el juego, ¿no? Vale, entonces aquí estamos preparando esas variables, una para jugar con el slider y coger 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:53:25

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? Porque en cierto momento, nosotros lo que vamos a ir es tocando este input field y lo que recogemos es el texto, pero son dos entidades distintas, ¿vale? 00:53:50

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étera, pues lo que va a ir cogiendo es cuatro textos que tengo preparado aquí en un array de strings. 00:54:13

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 serialize field. 00:54:27

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á. 00:54:55

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? 00:55:10

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? 00:55:31

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

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

Que se llama UpdateSlider. 00:55:58

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? 00:56:00

En este caso la dificultad con el slider. 00:56:13

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 input field, ¿vale? 00:56:16

Son dos. 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í? 00:56:25

preparar en público este método 00:56:41

llamado 00:56:44

updateInput 00:56:45

para que los cambios que vayamos haciendo 00:56:47

se guarden en el 00:56:50

gameManagerUserName, que era esta variable 00:56:52

estática. Y lo que va a coger es 00:56:54

el inputUserName.text 00:56:55

Esto 00:56:58

así dicho rápido. 00:56:59

Lo que estamos haciendo 00:57:01

es decirle que 00:57:03

voy al 00:57:05

inputUserName que 00:57:07

cada vez que se cambie, 00:57:09

Estoy en el input username. Son tantas cosas que por eso voy recopilando. Perdón que a veces puede ser un poco plomo, pero prefiero que vaya más a paso. 00:57:10

Si yo le digo que cada vez que se cambie un valor, coja del canvas, arrastro el canvas aquí y lo coge, que dentro de las opciones del canvas, que coja el método llamado configMenu y yo he hecho ahí un método que se llama dateInput, 00:57:21

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. Al final, lo que estoy haciendo aquí es que cuando yo escriba un texto, cada vez que cambie este valor, ¿no? Según lo que hemos puesto aquí, cada vez que cambie 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. 00:57:44

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

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. 00:58:25

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. 00:58:37

que es, creo que antes os he dicho que un texto era otro, pero básicamente este texto va a estar referido al texto de la dificultad, que es este que tenemos aquí, que se une aquí, ¿vale? Ese es el texto a secas y luego por otro lado tenemos el input field, ¿vale? Que es este texto que tenemos aquí en el input field, que no es el mismo, perdón, que antes os he hablado y me he liado, pero el input field tiene un campo de texto suyo, ¿vale? 00:58:53

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. 00:59:18

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. 00:59:33

al arrancar el nivel con el 00:59:57

hand manager, dice, ala 00:59:59

hemos creado tres variables que lo que hacen es 01:00:01

que pongo de username 01:00:03

que pongo de update 01:00:04

de vidas y también no de dificultad 01:00:06

que eso os lo cuento después si da tiempo 01:00:09

pero es para influir por ejemplo 01:00:11

en el rigid body de la bola 01:00:13

entonces 01:00:14

aquí nuevamente en el 01:00:16

hand manager, que de esto no hemos hablado 01:00:19

yo en el hand manager también he creado 01:00:20

un script que voy a ir 01:00:22

añadiendo todas las 01:00:25

los serialize field, todas las variables 01:00:26

que me vaya a interesar luego ir cambiando 01:00:29

de ese hand manager o incluso 01:00:31

remitiendo a un rigidbody de la bola 01:00:33

estoy accediendo al rigidbody de la bola 01:00:35

para luego cambiar sus propiedades 01:00:37

de mass y de drag para que 01:00:39

según la dificultad que pusimos 01:00:41

en el slider 01:00:43

según si es 01:00:45

el nivel 0, el 1, el 2 01:00:47

o el 3 de la barra 01:00:49

y se ha guardado 01:00:51

va a poner un peso 01:00:53

y un drag diferente, por tanto la bola 01:00:54

pues tendrá, será más fácil de mover 01:00:57

o caerá más rápido o bueno 01:00:59

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

vale 01:01:03

vale, entonces 01:01:04

básicamente estamos 01:01:08

usando nuevamente este game manager username 01:01:11

como gestor luego para cambiar 01:01:13

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

que tenemos aquí, que es el texto 01:01:17

que en el nivel 01:01:19

de 01:01:20

juego 01:01:22

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

aquí tengo un canvas con su propio 01:01:27

con un texto aquí preparado 01:01:29

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

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

que lo que tiene que cambiar es ese 01:01:39

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

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

a esto que 01:01:48

esto que yo le estoy diciendo aquí 01:01:50

¿Vale? Esto es ir siendo muy esquemático y decir, aquí voy a coger algo, tenerlo muy claro, escribirlo, ¿dónde se guarda esto que estoy cogiendo en tal sitio? Y luego, ¿dónde se carga? E ir, preparar la variable que sea necesaria y cargarlo. 01:01:53

Sí, sí, es denso, es denso y además cuesta 01:02:13

Es ir desgranando poco a poco 01:02:17

Creo que alguna vez os hablé de lo que es el pseudocódigo 01:02:19

Bueno, no es pseudocódigo 01:02:22

No sé cómo se llama 01:02:23

Pero en programación, en la ingeniería de informática 01:02:24

Que os lo cuento, pero yo no es que lo haya hecho 01:02:28

Yo no soy programador, ni mucho menos 01:02:30

Pero por amigos que tengo y gente que conozco 01:02:32

Ellos, para entender lo que tienen que hacer 01:02:35

Antes de meterse en el código 01:02:38

En una hoja van escribiendo 01:02:39

En el nivel 1 voy a tener un slider 01:02:41

que al moverse 01:02:44

va a guardar en otro script 01:02:46

que se llama tal 01:02:49

esto 01:02:50

el valor 01:02:51

del slider, una vez ha guardado 01:02:55

en el HUD 01:02:57

se va a ver reflejado, ponerlo con lenguaje 01:02:58

natural, un poco esquemático pero 01:03:00

con lenguaje natural, para tener siempre 01:03:02

en cuenta de dónde a dónde vamos 01:03:04

porque si no esto se va enmarañando 01:03:06

y es complicado, pero básicamente es eso 01:03:08

es ir sabiendo de dónde cogemos 01:03:10

contenido 01:03:12

donde guardamos esa variable y luego 01:03:14

de donde se recoge, dicho así es fácil 01:03:17

pero si lo ponemos 01:03:19

por escrito, pues es más fácil no perderse 01:03:21

y a lo malo es eso, que hay muchos 01:03:23

capitulitos y muchos apartaditos 01:03:25

que tampoco hay que hacer de una 01:03:27

primero hacemos este update username 01:03:29

y cuando ya funciona 01:03:31

vamos a lo del slider 01:03:33

poco a poco, pero sí que intentando 01:03:34

resumirlo 01:03:37

o ponerlo todo dentro de scripts 01:03:39

que congreguen, pues eso 01:03:41

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. Pero lo pone todo dentro de un único script, porque si también se digrega mucho, también se vuelve una cantidad de script que hay que ir conectando e ir moviendo que se vuelve un poco tedioso el tema. 01:03:42

Vamos con el slider, si os parece. La vida, aquí es una imagen que se va cargando, por defecto es la de 3, pero básicamente esto se debe a que cuando empieza el nivel, hacemos esto de cargar vidas. 01:04:05

y esto de cargar vidas es 01:04:25

si el game manager 01:04:27

las vidas en algún 01:04:29

momento han llegado a cero, es decir, ya hemos jugado 01:04:32

y fueron 01:04:34

y llegaron a ser 01:04:35

cero 01:04:38

directamente ya guarda B3 01:04:40

para tenerlo ya preparado de que 01:04:42

cuando reinicie el juego sean 3 01:04:44

pero básicamente en todo momento 01:04:45

lo que tiene que ir cogiendo son 01:04:47

la cantidad de vidas que tengamos 01:04:49

guardada en el game manager 01:04:52

y de hecho, si no me equivoco 01:04:53

a ver, un segundo 01:04:55

nada, no 01:04:57

os iba a enseñar una cosa que no es 01:04:59

que no es real, pero eso 01:05:01

que lo que es 01:05:03

el, joder, es que se me está cambiando 01:05:05

todo el rato el este 01:05:07

si al empezar el juego 01:05:09

no hemos hecho nada, pues pónmelo en 3 01:05:11

si no, cada vez que yo vaya metiéndome en ese nivel 01:05:13

no toco esto, ¿vale? 01:05:16

salta este bucle 01:05:17

y solo se recarga 3 cuando son 3, si no 01:05:18

lo que se irá haciendo es que se irán restando 01:05:21

vidas, ¿vale? recordad 01:05:23

que en el juego, 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, ¿vale? En ese caso sí que hay que tocar algunos de los códigos que teníamos antes. 01:05:25

Es decir, si nos metemos en donde precipicio, nos meteremos, a ver si quiere enseñármelo, precipicio, aquí está, ¿vale? Y aquí metemos mano a GameManagerLives y restamos uno cuando se cae, ¿vale? 01:05:42

Pues empezamos con tres realmente, dos, uno y cuando es cero, aparte de que esto ya obliga a cargar cuando nos hemos caído la escena cero, que es la que hemos puesto aquí, pues también eso nos va sirviendo, como lo estamos guardando en este Game Manager de orden superior, nos va sirviendo en todo momento para ir cargando la imagen que nos corresponda, ¿vale? 01:05:57

Esta imagen es un array que hemos creado aquí con distintos sprites, ¿vale? Por un lado está el componente imagen, que es el que carga la imagen, ¿vale? Si nos metemos aquí hay un componente imagen que es el que carga la imagen y luego otra cosa diferente es la variable de tipo sprites, que son las imágenes en sí, ¿vale? 01:06:22

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? 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:06:46

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:07:16

Es decir, si nos quedan dos vidas, directamente carga el segundo elemento, bueno, el tercero, el 0, 1, el 2, elemento del array que coincide con el de las vidas. 01:07:42

Esto si no habría que dar más vueltas, pero si se hace coincidir, pues directamente cuadra. 01:07:51

Vale, vamos con el slider. 01:07:56

El slider es lo mismo que hemos visto hasta ahora, pero tiene un nivel de complejidad quizá mayor. 01:08:01

A ver, perdón, que me trabo aquí buscando las cosas. 01:08:08

tiene otra dificultad, que es que lo que va recogiendo son valores numéricos, y valores numéricos de tipo float, y hay que hacer una conversión, y vamos a verlo, ¿vale? 01:08:12

En este slider, pues aquí ya como había puesto, hay otro texto para que lo he metido dentro de lo hecho hijo, de lo que es todo el slider. Vamos, aquí está el slider en sí y he hecho otro padre, otro entity para que todo se mueva de golpe, pues un titular que es dificultad y este texto que es el que se va cambiando con el array que os he puesto antes, que irá cargando el texto de este array de dificultad que tenemos aquí, ¿vale? 01:08:25

Pero vamos al slider, que es esto de aquí. El slider, además, tiene bastantes elementos. También lo indica el tema, pero sobre todo se puede cambiar la imagen, que es el handle, que es el manejador de lo que movemos. 01:08:52

Bueno, pues es una imagen. Aquí podemos arrastrar otro elemento. Indica además que es de los pocos elementos de User Interface que es mejor escalar que arrastrar porque se puede pixelar. Cuando hagáis las pruebas, si cuando vayáis cambiando el tamaño del slider se os empieza a pixelar, es de los pocos que sí que hay que escalar. 01:09:08

Porque si no empieza a pixelarse, es decir, si yo lo que hago es cambiar el fill area, me voy aquí, arrastrando aquí, bueno, no es fill, sería esto, el conjunto, sí que sobre todo cuando se haga de otras proporciones veis que empiezan a distorsionarse elementos. 01:09:29

Entonces, para el largo a lo mejor no os da problemas, pero el handle sí que os va a dar problemas. 01:09:49

Entonces, es de los pocos que hay que preparar, si vais a meter la imagen de la bola, 01:09:54

pues que tenga una resolución adecuada por si se hace un poco más grande. 01:09:59

Pero vais a ver que es de los pocos que sí que se aconseja hacerlo más grande con la escala, 01:10:03

porque si no, os da problemas. 01:10:07

Vale, lo dicho, tenemos este fill area, tenemos distintos elementos para cambiar un color, 01:10:10

para decir que cuando va pasando la bola 01:10:17

acame de color, pero toda la chicha 01:10:19

básicamente está en el padre 01:10:21

que es el que da aquí 01:10:22

en el componente slider 01:10:24

el que va recogiendo en este value 01:10:26

el valor 01:10:29

dentro de lo que se haya cargado o no 01:10:30

la barra, el valor 01:10:33

de carga, se va a interpretar 01:10:35

como números, aunque aquí ponga 01:10:37

lo de fácil chupado, eso se va a ir 01:10:39

relacionando en base al número que tengamos aquí 01:10:41

va a cargar el slider 01:10:43

el texto del array de dimensión 01:10:44

una 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:10:47

importante bueno aparte de que el slider se puede poner de arriba abajo de izquierda a derecha por 01:10:55

si queremos que suba o baje vale de una forma rápida bueno aquí se le ha ido la pinza un 01:11:00

segundito vale y por tanto si queremos cambiar la dirección no habría que rotarlo vale que sería a 01:11:06

a lo mejor el comportamiento así primero que no vendría, 01:11:13

sino que habría que cambiar la orientación aquí, ¿vale? 01:11:18

Y de momento me interesa que vaya de izquierda el 0, 01:11:21

a derecha el máximo, sería esta la configuración. 01:11:24

Muy, muy importante, habrá que configurar el slider 01:11:28

con su mínimo y su máximo, ¿vale? 01:11:31

En este caso, se pone de 0 al 3 porque queremos 4 niveles de dificultad. 01:11:34

Tened en cuenta que el 0 ya es un valor, ¿vale? 01:11:39

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, ¿vale? Entonces, yo ahora, si os fijáis que he puesto que vaya del 0 como punto de partida, aunque también se podría cambiar, ¿eh? También podría ser que empiece en el 1, pues el 1 sería el valor de inicio y a medida que voy arrastrando, veis que ahora hay muchos más pasos, ¿vale? 01:11:41

Y hay otro valor también importante, que es que aparte del límite, se puede dejar, como viene por defecto, si no me equivoco, para que sea un float, y vais a ver que el valor ahora que va cogiendo es de un float, porque tiene valores decimales, o que sean números enteros, ¿vale? 01:12:11

Aquí he cambiado algo del tamaño, ¿veis? Ya la he liado un poco. Pero veis que cuando ponemos esto de whole numbers, hacemos que los saltos sean entre unidades enteras. ¿Vale? ¿Qué problema vamos a tener con esto? Que aunque aquí pongamos esto de whole numbers, al nivel de código, esto está preparado para que funcione con floats, con decimales. Y lo que va a tener que recibir es un float. ¿Vale? Esto es una dificultad que hay ahí. 01:12:32

A ver, un segundo, a ver si encuentro el por qué pasó esto, el fill, a ver, un segundín, aquí el handle, algo que cambia aquí, que se ha descoyuntado, sería el fill area, bueno, aquí puede ser, a ver, un segundo, algo que cambia ahí, que se le ha ido un poco, bueno, un segundo, 01:12:57

No, aquí no es. Bueno, esto, bueno, si no tocáis nada raro, pues no pasa esto de que se desconfigura el... Tendría que hacer la prueba de escalar, a ver, un segundo, no sé por qué esto ha cambiado, pero bueno, habría que ajustarlo ahí y ahora sí que lo hace. Bueno, algo, cuando he escalado, fijaos, ¿qué ha pasado eso? Bueno, ya estamos otra vez. 01:13:29

Bueno, vuelve a estar mal porque tendría que ajustar esto al valor que tenía 01:13:56

Porque lo he cambiado en reproducción, pero es eso lo importante 01:14:03

Lo dicho, para lo que nos interesa, que son niveles de dificultad 01:14:07

No queremos decimales, preferimos que sean valores enteros 01:14:11

Y aquí, cada vez que se toque, cada vez que se cambie el valor 01:14:14

Hay un evento ya preparado en los sliders 01:14:19

Que como sucedía en el de escritura en los input fields 01:14:22

Podemos poner que llame a uno o varios 01:14:25

Se pueden ir incluyendo más acciones 01:14:30

Y antes os he dicho que cuando cargamos otro elemento 01:14:31

El canvas, voy a hacer una cosa 01:14:35

Vienen aquí más cosas, se podría decir 01:14:37

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

Sino decir directamente que el GameObject cuando lo toquemos 01:14:44

Se active o se desactive 01:14:47

Es decir, que cuando toque esto se desactive 01:14:49

Entonces vais a ver ahora que, 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, ¿no? 01:14:52

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:15:06

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:15:24

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:15:43

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:15:56

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:16:09

¿Qué implica eso? Que para que luego no dé 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:16:23

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:16:37

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:17:03

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, 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:17:16

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, 01:17:46

lo convertimos ahí, ¿vale? Pues cuando vayamos moviendo, y luego, este dificultad text, ¿vale? Aquí lo que estamos haciendo en todo momento es que estamos aludiendo a este dificultad text 01:17:53

que habíamos guardado, es decir, que habíamos establecido con las cuatro variables del array 01:18:07

para ir cambiando este texto y se irá lanzando un elemento del array u otro 01:18:13

según la posición del array que lancemos que coincidirá con la del tipo int. 01:18:19

Y por eso lo hacemos de tipo int, porque para que el array que tiene posiciones fijas se vaya lanzando 01:18:27

lo convertimos en tipo int. 01:18:31

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, el valor del slider, también como un entero. ¿Y qué vamos a ir haciendo en todo momento? Guardar en la variable estática llamada dificultad el nivel de dificultad. Y aquí sí que puede ser float o int, lo que nos interese. 01:18:33

entonces digamos que cada vez que tocamos el slider 01:18:55

hasta aquí estamos guardando por un lado 01:19:00

en la variable estática el nivel de dificultad 01:19:02

por un lado y en otro estamos preparando 01:19:05

para que aquí nos muestre el texto de este array 01:19:08

que habíamos generado aquí 01:19:11

que tiene cuatro posiciones 01:19:12

cargará este array 01:19:16

según la posición que tenga 01:19:18

irá cargando uno de estos strings 01:19:22

en este campo de texto que tenemos ahí. 01:19:24

Luego, por otro lado, esto también se explica en el tema, 01:19:27

se pueden usar, esto es un poco opcional, 01:19:32

se podría de otra forma, los player prefs. 01:19:34

Que los player prefs es, digamos, de hacer un guardado 01:19:36

que va incluso más allá de las variables estáticas. 01:19:39

Las variables estáticas funcionan 01:19:43

mientras está la ejecución de ese juego. 01:19:45

Es decir, en una partida, hasta que no se apague la reproducción, 01:19:48

hasta que no se pare el juego, básicamente, pues entre niveles y entre elementos se pueden ir almacenando esas informaciones. 01:19:52

Con los player prefs, básicamente lo que hacemos es guardar en el ordenador, en el sistema operativo, en algún punto de nuestra memoria del ordenador, 01:19:59

variables o valores que pueden ser rescatados incluso entre partidas. Es la diferencia. 01:20:07

Luego en el tema también os pongo que los player prefs se guardan en el sistema operativo, 01:20:14

pero se pueden guardar en archivos tipo Json, estos más avanzados, pero que digamos que se pueden subir a una nube o se pueden subir y entonces se guardan en la nube con un nombre 01:20:19

y se recogen en la nube con un nombre de una forma más o menos un poco más compleja, más larga, pero similar a esta. 01:20:28

¿Qué es? Que nosotros podemos ir dando, igual que si tuviéramos un Excel, vamos a decir, podemos ir creando tablas en las que poner en una casilla un nombre 01:20:35

y en la siguiente el valor 01:20:45

o lo que estemos guardando, el valor de lo que guardemos 01:20:46

aquí por ejemplo, estamos diciendo 01:20:49

en los player prefs, los player prefs 01:20:51

siempre aparecen, no hay que hacer nada 01:20:53

extraño, están ahí, ¿vale? 01:20:55

y tienen sus propios métodos aquí 01:20:56

que se habla de ellos, de hecho se habla de todos los que tienen 01:20:58

se describen en el tema 01:21:01

¿vale? pero aquí en este momento 01:21:02

cada vez que movamos el slider 01:21:05

se está, recordemos 01:21:06

en el... 01:21:08

aquí 01:21:11

Aquí. Joder. No. Aquí. Y este no. Joder, qué tostón. Vale. Aquí. En el slider, recordad que cada vez que toquemos, activa el método updateSlider. 01:21:11

Entonces, cada vez que toquemos, podemos estar guardando en ese sistema operativo, en ese archivillo, con el nombre clave, digamos, de dificultad, 01:21:27

Porque es lo que estamos guardando 01:21:37

El nombre que le estamos dando a este dato 01:21:38

Pues lo que estamos guardando es 01:21:40

El valor del slider 01:21:42

Realmente aquí también podríamos poner dificultad 01:21:44

Directamente porque es lo mismo 01:21:47

Pero bueno, así queda más claro 01:21:48

Según lo recoge ya, mete este valor 01:21:50

Y lo va a meter como un float 01:21:53

Bueno, pues como un float 01:21:54

Y eso significa que aparte de estar guardándolo 01:21:56

En el GameManager 01:21:59

Yo también podré recurrir 01:22:00

A los PlayerPrefs para recuperar datos 01:22:02

Por ejemplo aquí 01:22:05

hay una cosa que es 01:22:06

que en el, esto ya es más opcional 01:22:09

pero que en lo de los 01:22:11

player prefs, os lo digo un poco para que sepáis como funciona 01:22:12

pero una de las 01:22:15

opciones es que cuando se arranca 01:22:16

el 01:22:18

este script, que realmente se 01:22:19

arranca cuando entramos 01:22:22

en el menú de configuración, cuando damos 01:22:25

al botón de config desde el menú 01:22:27

inicial, nos metemos aquí y al arrancar 01:22:28

dice, oye si en algún momento 01:22:31

se ha creado, esto es una booleana 01:22:33

Al final es una condición que es una boleana. Es uno de los métodos que tienen los player prefs, que es, si existe este código llamado dificultad, ejecutalo de dentro. Si alguna vez ya se había creado, la primera vez que juguemos no va a suceder. 01:22:35

La segunda, en cuanto hayamos tocado el slider, ya se ha generado este código, este campo en las player prefs y habrá guardado un valor. Entonces dice, si alguna vez has jugado y existe esta dificultad, pues por defecto lo que es el valor, 01:22:49

pues voy a decir 01:23:09

a aludir aquí 01:23:10

el valor de 01:23:12

de este slider 01:23:14

que sea el que habíamos 01:23:17

coge ese float y pone ese valor 01:23:18

¿vale? en base a ese nombre 01:23:20

por eso, aunque 01:23:22

fijaos, es verdad que las 01:23:24

playerprefs se generan 01:23:26

se generan cuando 01:23:28

cuando 01:23:30

digamos 01:23:32

sobre todo cuando se está jugando 01:23:35

pero fijaos que yo ahora 01:23:37

aunque pare la reproducción, cuando le doy 01:23:38

al play, se está cargando 01:23:41

el último estado que había dejado 01:23:43

¿vale? ya no es entre niveles, es entre 01:23:45

partidas, entonces yo ahora por ejemplo 01:23:47

lo pongo en normal 01:23:48

¿vale? y paro 01:23:50

¿vale? ya las variables estáticas han olvidado 01:23:52

todo, se han descargado, el juego ha parado 01:23:55

podemos habernos ido a apagar 01:23:57

el ordenador, si esto fuera 01:23:59

el compilado ¿vale? pero bueno, ahora estamos 01:24:00

digamos recreando lo que pasaría en el compilado 01:24:02

si yo vuelvo a arrancar el juego 01:24:05

como estoy en el mismo sistema operativo 01:24:07

y ese archivo de las player prefs 01:24:09

se ha almacenado ahí, lo buscará 01:24:11

y dirá, sí, sí existe esa 01:24:13

dificultad. Y por eso arranca 01:24:15

ya con el valor de 01:24:17

2 en este caso, ¿vale? 01:24:18

Que es en el que lo habíamos dejado. 01:24:21

Entonces, bueno, en los player prefs 01:24:23

el problema que tienen, esto se usaba 01:24:24

por eso se llama player preferences 01:24:27

se usaba, por ejemplo, 01:24:29

en las 01:24:31

máquinas recreativas 01:24:32

para guardar los listados 01:24:35

De los mejores, en plan 01:24:36

El número uno hizo 50.000 puntos 01:24:38

El dos, 30.000 01:24:40

El problema de los ordenadores es que si buscas ese archivo 01:24:41

Y lo cambias a mano, pues es muy fácil 01:24:43

Manipularlo, para que de pronto te cargue 01:24:46

Lo que tú quieras 01:24:48

Pero bueno, ya os digo que esto es una especie de primer 01:24:49

Paso, o versión simplificada 01:24:52

De lo que se puede hacer 01:24:54

Con archivos que se guardan a la nube 01:24:55

Y se almacenan en sistemas, que es lo que sucede 01:24:58

Cuando se juega juegos en la nube 01:25:00

Que se van guardando datos en la nube 01:25:02

O en una memory card, o etc 01:25:04

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:25:06

Pero bueno, en esencia ese es un poco lo que está configurado. Luego, cuando ya tenemos la dificultad, en el HUD Manager, al que digamos en cada nivel estamos accediendo al RigidBody de ese nivel, porque lo arrastramos al SerializeField, la bola, o porque aquí hiciéramos, aquí no lo he hecho así, lo he hecho por SerializeField, pero un GetComponent y ese componente del RigidBody de ese nivel, 01:25:24

pues luego podemos ir y decir 01:25:52

oye, guárdame en una 01:25:54

variable 01:25:56

local 01:25:57

lo que valga dificultad 01:25:59

que es básicamente lo que se ha guardado 01:26:01

como valor del slider cada vez que lo hemos ido 01:26:03

cambiando, ¿vale? entonces 01:26:06

si lo hemos dejado en 2, yo aquí luego 01:26:07

lo que puedo hacer es decir, ah, vale, como si la dificultad 01:26:10

es la de normal 01:26:12

que es la de 2, esto también se podría 01:26:14

hacer con un switch, ¿vale? 01:26:16

en vez de hacer tantas condiciones, pero bueno 01:26:18

en esencia lo mismo 01:26:20

pues si la dificultad que habíamos guardado 01:26:21

que se guardó en esa variable 01:26:23

estática es 2 01:26:25

pues la masa de la bola 01:26:27

accedo a 01:26:29

al RigidBody 01:26:31

que lo había llamado como bola 01:26:33

y ya aquí puedo cambiar pues que sea más o menos 01:26:35

pesada, que tenga otra inercia 01:26:37

que tenga gravedad, que no 01:26:39

y aquí pues básicamente voy cambiando las condiciones 01:26:41

y vais a ver que la bola es más 01:26:44

pesada, sobre todo para el nivel que va 01:26:45

rotando la tabla, es más pesada 01:26:47

y tiene menos drag para que caiga más rápido 01:26:49

de la tabla y sea más difícil 01:26:51

pues a medida que tiene más dificultad 01:26:53

en el 3 es donde más hay menos drag tiene 01:26:54

¿vale? 01:26:57

y con esto más o menos 01:26:59

os he ido contando un poco todo 01:27:01

un poco rápido 01:27:02

luego en el menú inicial 01:27:03

el botón de salir 01:27:07

simplemente para que lo sepáis 01:27:08

en el menú inicial 01:27:11

no lo guardo 01:27:13

en el de salir 01:27:15

lo pone también en el tema 01:27:16

que cuando queremos cerrar 01:27:18

cuando hagamos el compilado del juego 01:27:22

si queremos que al dar a ese botón 01:27:24

o cuando sea, se cierre el juego 01:27:26

está este método 01:27:28

el Application Quit, pero esto no se ve reflejado 01:27:30

al reproducir 01:27:33

en el editor 01:27:35

no se puede cerrar de esta forma 01:27:36

porque si no, supongo que interpretaría 01:27:38

que lo que tiene que cerrar es 01:27:40

la aplicación de Unity 01:27:41

entonces la dejamos aquí y sabemos que funciona 01:27:43

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? Ahí 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:27:46

dudas 01:28:13

leo una que hay, el valor máximo 01:28:18

que tienes es 3, sería que la barra 01:28:21

se secciona en 3 partes 01:28:23

así que el botón de la barra 01:28:25

tiene 4 posiciones, inicio, claro 01:28:27

realmente tiene 4 01:28:28

porque tú empiezas por el 0 01:28:31

es decir, vamos aquí 01:28:33

input 01:28:35

no, input no 01:28:37

dificultad, vale, yo he cambiado 01:28:39

el slider, le he cambiado el nombre a dificultad 01:28:41

pero bueno, aquí slider 01:28:43

dificultad, que se puede cambiarlo en nombre, sin problema 01:28:45

cuando tú estableces el mínimo 01:28:47

el valor 0 y el máximo el valor 3 01:28:49

0 es un valor 01:28:51

1 es otro valor, 2 es otro valor 01:28:52

y 3 es otro valor, por tanto 01:28:55

hay 4 posiciones 01:28:57

puede ser de 0, 1, 2, 3 01:28:58

4 posiciones 01:29:01

¿vale? lo mismo, aquí en realidad 01:29:02

en otros momentos, en una pantalla de carga 01:29:05

¿vale? que un slider 01:29:08

puede servir para mostrar una pantalla de carga 01:29:09

mientras voy haciendo así, fijaos 01:29:11

como la bola, si en el async 01:29:13

Hay un apartado sobre los async. Va mostrándose esta carga, sirve con decimales en este caso, si no queremos que haya valores, para cargar esa barra. Si yo quitara esto del handle, black, y dejo solo el fil área, básicamente esto es una barra de carga. También puede usarse para eso. 01:29:15

vale, lo vuelvo a activar 01:29:36

pues sí, planteame 01:29:39

la duda, si nadie más dice nada 01:29:42

será que no la sé 01:29:43

vale, a ver 01:29:45

una duda así chiquitita 01:29:47

por ejemplo 01:29:49

lo que es todo el HUD 01:29:51

del sprite y de los textos 01:29:52

si no quisiéramos ponerlo en lo que es en la cámara 01:29:55

la cosa es para ponerlo 01:29:57

encima de la bola y que le siga 01:30:01

como si fuera el típico juego RPG 01:30:02

tendrías que trasladar lo que es el HUD 01:30:05

ponerlo como hijo 01:30:07

de la bola? 01:30:09

Sí, habría que hacer dos cosas 01:30:10

voy a ver... 01:30:12

Y claro, ahora que te lo estoy diciendo, claro, si lo pones 01:30:14

como hijo de la bola, cuando gira la bola 01:30:17

¿se mantendría arriba estático 01:30:19

o giraría al eje 01:30:21

de la bola? No sé si me explico 01:30:23

Sí, voy 01:30:24

Tú ten en cuenta, y para eso está 01:30:26

esto de canvas, que tú aquí si dices que esté 01:30:28

como un overlay, va a estar como un overlay 01:30:30

¿vale? Eso es a nivel de visionado de cámara 01:30:32

Está casi pensado para eso, para hacer interfaces a nivel de menús, pues eso, que se sobrepongan, que estén, digamos, siempre en un mismo espacio. 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... 01:30:34

otros a ver ahí tiene otros valores de pronto le sale la pinceta etcétera tú 01:31:04

puedes coger ahora y ese canvas y hacerlo hijo de él 01:31:15

bueno claro es que esto es un prefab habría que desempaquetar probablemente 01:31:19

no 01:31:27

Un segundín, ¿eh? Porque es lo que te digo, children of a prefab instance, ah, vale, no, es que yo, vale, el hat lo he metido como un prefab, entonces habría que liberar el prefab y meterlo como hijo de la bola. 01:31:30

Vale, entonces ahora, si yo moviera esto para que estuviera en posición con la tabla, a ver un segundín, ¿dónde está la bola? 01:31:45

Ahí está la bola, claro, es que es muy pequeño. Aquí hay que ajustar el canvas para que esté con, vamos a hacerlo más pequeñete, 01:32:01

A ver, un segundo. Esto hay que hacerlo más pequeñito y hay que colocarlo en posición. Básicamente ahora lo que pasa es que tiene unas dimensiones descomunalmente grandes. Ahora, si te fijas, tenemos ese canvas que se podría ajustar en el espacio. 01:32:15

Y si yo sigo haciendo lo más pequeño, 500, 500, ¿ves que ya van apareciendo como en el espacio? Vale, a ver, un segundo. Ahora vemos las pegadas de esto, ¿vale? ¿Ves que se está moviendo con la bola? Lo que pasa es que he movido la bola o algo así, debe ser. ¿Dónde está la bola ahora? Bueno, vale, que aquí he cambiado algo. 01:32:50

Básicamente 01:33:22

Ahora, un segundo 01:33:24

Vale 01:33:26

Vamos aquí 01:33:28

Y esto lo tengo que seguir haciendo más pequeñito 01:33:29

A ver, ¿dónde está el campeón? 01:33:36

Joder, ¿y dónde 01:33:49

Tengo yo esto? Ah, bueno 01:33:50

No sé por qué se pone ahí 01:33:55

Vale, ahí 01:33:56

Ahí lo pongo un poco más arriba 01:33:59

Habría que reajustar todo lo que hay dentro 01:34:01

De ese canvas, lo voy a hacer todavía 01:34:03

Más pequeño 01:34:05

Esto es porque también justo esta bola es muy pequeña, pero si lo colocamos ahí, habría que reconfigurar todo, pero fíjate. 01:34:06

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:34:26

Porque está cogiendo la fuerza. Habría que, por código, decir que siguiera el transform de la bola, ¿vale? 01:34:36

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, 01:34:44

Vale, lo lógico, 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, y aquí de hecho lo que habría que hacer es 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, 01:34:53

Porque le estamos dando con él, entonces rota con ello. 01:35:22

Por eso hace estas cosas raras. 01:35:24

Habría que asociarlo por código que vaya cogiendo el transform position 01:35:26

y se mueva con position para que no vaya adquiriendo estas rotaciones. 01:35:32

¿No valdría un MP object como padre y ambos dentro? 01:35:38

Sí, lo único malo es que como en este caso la bola siempre la estás rotando, 01:35:44

si lo que quieres es que se mueva con una fuerza de la bola, 01:35:49

el padre no se está moviendo. 01:35:52

¿Sabes lo que te quiero decir? 01:35:54

Pero bueno, hay que buscar la manera de que 01:35:56

aunque la bola la movamos así, 01:35:58

que lo que vaya leyendo en todo 01:36:01

momento sea la posición de la bola 01:36:02

y no todo, ¿sabes? Que es lo que hace cuando 01:36:04

lo haces hijo. 01:36:06

Y eso por lo digo ya lo sabéis hacer. 01:36:08

Entonces, pues que... Pero te vuelvo 01:36:10

a decir, bueno, a lo que iba. 01:36:12

En 3D Objects, en vez de meter desde UI 01:36:14

los elementos de la UI, 01:36:16

que lo que hace es crear el canvas, 01:36:18

también se pueden crear como objetos 3D. 01:36:20

Entonces tú puedes ir aquí y decir que se cree un texto, 01:36:23

que si le damos aquí, por ejemplo, 01:36:27

este texto ves que no se mete por defecto dentro del canvas 01:36:29

y, sin embargo, ya está en Z. 01:36:32

Entonces, si lo que quieres cargar es un texto, por ejemplo, 01:36:36

simplemente se puede meter como un objeto. 01:36:41

O, lo digo esto porque los textos sí que es verdad 01:36:44

que son editables, etcétera, 01:36:46

Pero tú normalmente cuando quieras cargar una imagen, también lo que puedes hacer es crear un plano y como textura ponerle una imagen y ponerlo ahí, que no sería un elemento de User Interface. 01:36:50

Lo que va variando es el contenido de un texto, los números, la vida, etc. 01:37:02

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:37:08

Y luego también un plano le puedes poner una foto o un corazón, ¿vale? Es decir, si tú aquí en el material que tengas, habría que crear un nuevo material, crear un material, material, material, ¿vale? Y dices imagen, yo qué sé, el corazón. 01:37:22

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. 01:37:39

De esto también hablaremos ya en otro momento, pero fíjate que tú ya a este plano le puedes poner un material que sea ese corazón. 01:37:53

Entonces, no, en X, evidentemente, y será menos 90, entiendo, o no, más bien 90. 01:38:03

Lo que pasa es que ahora está por el lado que no tiene que ser, pero que con esto también se podrían hacer, 01:38:12

Habría que meter un alfa para que lo capte bien, etcétera, pero que puedes meter elementos luego que en realidad son elementos 3D y nuevamente lo puedes asociar a la bola. 01:38:17

Pero bueno, con lo que hemos visto de la UI, básicamente es como te he dicho, poner que su render mode sea workspace, que básicamente es que se convierte en un objeto con su transform normal. 01:38:28

Aunque metas aquí luego los anchors y tal, en realidad aquí están sus parámetros, ¿vale? 01:38:40

vale 01:38:47

vale, vale 01:38:49

por ahí sería por donde yo tocaría 01:38:51