Tutoría 6 - DEIM - UT2 y UT3 - Curso 24-25 - 14 Enero

Un compañero ha dicho que la tarea la va a empezar tras esta tutoría y la entrega, si no me equivoco, es en pocos días, en lunes, ¿no? Si no me equivoco. O el domingo, exacto. 00:00:01

Vale, no sé si, creo que alguna vez lo he explicado, pero la función de las tutorías es, nosotros damos clase, porque, bueno, damos clase, damos como pautas, digamos, más allá de los temas incluso, porque consideramos que es una buena práctica y, bueno, que nuestro ciclo en concreto es muy práctico y, bueno, tiene muchas ampliaciones y muchas cosas a tener en cuenta, ¿no? 00:00:11

Pero en teoría las tutorías están planteadas para que vosotros planteéis vuestras dudas. Entonces, creo que es mal enfoque y desde luego no es el que se supone por el que se hacen las tutorías a nivel normativo, me refiero, que hagáis las tareas después de las unidades. 00:00:39

De lo suyo es que vayáis estudiando los contenidos y vayáis al menos intentándolo para tener estas dudas, ¿vale? 00:00:56

Lo digo porque si no luego os ponéis con la tarea, la entregáis el domingo, si las dudas surgen el sábado, pues no vais a tener respuesta, claro. 00:01:02

Y aparte que se aprovechan más si ya, no digo a lo mejor tenerla toda hecha, pero sí haber visto los problemas y las vueltas y lo que os pueda asustar de la tarea, 00:01:11

intentarlo y donde 00:01:19

os quedéis atascados es donde 00:01:20

pueden surgir esas dudas 00:01:23

más allá de que ahora 00:01:24

que esto también nos envía un mensaje 00:01:27

en este sentido, más que yo vaya enseñando 00:01:29

código de cómo se podría resolver 00:01:31

y simplemente lo paréis y lo copiéis 00:01:33

¿vale? A nivel aprender 00:01:35

no es lo más razonable 00:01:37

evidentemente, y lo sé 00:01:38

y soy consciente y cada vez va a ser peor 00:01:41

en este sentido, es fácil atascarse 00:01:43

¿vale? Pero 00:01:45

Pero, en fin, lo importante es intentar ir resolviendo los problemas que van surgiendo. Me indica que es por tiempo, lo sé. Es decir, yo luego cada uno tiene lo de siempre en esta modalidad. 00:01:46

Si yo sé que el tiempo es limitado, requiere también sacar tiempo para ir llevándolo al día, pero bueno, simplemente quiero que quede claro que el planteamiento sería ese, el más adecuado, ¿vale? Luego pues cada uno llegará hasta donde pueda, etcétera, pero sí que hay que ir llevándolo al día, ¿vale? Siempre lo he dicho, pero este módulo si no es bastante complicado, pero bueno, intentad llevarlo lo mejor posible. 00:02:02

Luego, por otro lado, por un comentario que recibimos, ya se dijo en varias ocasiones, pero simplemente, aunque no es lo recomendable, pero las actividades aquí no es obligatorio entregarlas, porque a veces nos llegan, vosotros de verdad que estáis con módulos de segundo en la mayor parte, pero no es obligatorio entregarlas para aprobar. 00:02:30

Tenéis que aprobar en el examen final, que por cierto, otro comentario, ya como el año pasado ya sucedió, no solo van a ser preguntas tipo test, cada vez va a haber más preguntas de desarrollo o de relacionar o digamos que implique más conocimiento que resolver un tipo test. 00:02:52

Que lo habrá, casi seguro, en alguna parte, pero también va a haber de desarrollo. También porque ya os dije que ahora se pide que no solo aprobéis por nota, sino que cubráis los resultados de aprendizaje. Y para que eso se vea hay que hacer preguntas que interrelacionen los distintos temas, no solo tipo test. 00:03:07

Vale, entonces simplemente tener en cuenta eso. Luego, por otro lado, por último, por mi parte antes de ponernos, os estoy compartiendo pantalla, imagino que estáis viendo la aula virtual, ¿vale? 00:03:24

En los temas, esto también creo que lo he dicho ya alguna vez, está la sección de contenidos con el contenido en este formato navegable, en donde todo se ve como está previsto que se vea y luego damos otras dos formas de estudio que es, a ver si carga, a través de un PDF de esos contenidos, pues abro esta por ejemplo, a través de un PDF de los contenidos, que está aquí, y de una versión página web, 00:03:39

Que es que está todo, digamos, del tirón. Y menos en el PDF, igual en alguno de los primeros temas no está todavía implementado, si alguien lo necesita muchísimo lo hacemos, porque todavía no habíamos descubierto esta forma así, pero hay un encabezado en el que podéis hacer más grande y más pequeño y cambiar la fuente del texto. 00:04:07

Por si os viene bien o tenéis alguna dificultad, os conviene hacerlo así, que lo sepáis. Es verdad que el PDF no se puede ampliar o no, porque cuando se guarda el PDF se ve como se haya guardado. Lo pongo al tamaño como estándar, pero si quisierais tenerlo en otro tamaño más grande, podéis hacerlo en la versión de página única más grande y dando a clic derecho a imprimir, suele salir una opción. 00:04:29

o deberíais tener una opción de Adobe PDF o guardar como PDF, etcétera, ¿vale? 00:04:56

Si no, buscad en internet qué extensión os permite guardar en estos formatos y instaláis, ¿vale? 00:05:01

Pero con esto sí que podéis hacer el texto más grande para guardároslo al tamaño que queráis. 00:05:07

Si lo queréis estudiar en PDF, que esto yo lo concibo, pues a lo mejor para subrayar o alguna cosa, 00:05:11

pero en estos PDF es muy habitual que no, sobre todo si cambiáis esto de los tamaños de tipografías, 00:05:17

que, bueno, pues que no van los enlaces, no van los vídeos de alguno, etc. 00:05:22

Entonces, esto es como complemento, pero recuerdo, lo importante es el contenido. 00:05:29

Y dentro del contenido es lo que sea contenido y lo que pone, a ver si encuentro alguno, 00:05:35

las secciones de saber más, ¿vale? Son para eso, para saber más. 00:05:40

No van a estar metidas en el examen. 00:05:44

evidentemente esto es trampa 00:05:47

es decir, ¿deberíais leerlo? 00:05:50

sí, deberíais leerlo, pero tampoco 00:05:52

si no lo entendéis de esta 00:05:54

suele ser a veces incluso para que volváis 00:05:55

cuando habéis ido a temas más avanzados 00:05:58

porque se suelen dar pues eso, ampliaciones 00:05:59

y se va a entender mejor después 00:06:02

si no es, es decir, directamente 00:06:03

si está en un saber más no se debería preguntar 00:06:06

esto, ¿vale? pero bueno 00:06:08

esto es como lo de las tareas, las tareas 00:06:10

aunque acabo de decir que son voluntarias 00:06:11

en las tareas se entiende 00:06:13

que estáis, aunque no las hagáis, se entiende que se están pidiendo cosas que deberíais más o menos saber hacer, o si hicierais la tarea, aunque no la entreguéis, se entiende que vais a salir de este módulo sabiendo realizarlas o al menos encararlas hasta cierto punto. 00:06:15

Por eso leerlas, porque además en las propias tareas también se dan explicaciones 00:06:33

Normalmente más avanzadas, pero también es una parte del curso, digamos, evaluable 00:06:38

Me han escrito sí, me he dado cuenta a medida que iba cursando el grado 00:06:45

Entiendo que ha ido evolucionando y cambiando de algo muy teórico a tener más elementos prácticos 00:06:49

Lo bueno del formato PDF es que los minitests que tienen ciertos módulos 00:06:53

Vienen con las respuestas correctas para saber si has respondido bien 00:06:57

Pero eso no está en el formato PDF, eso está en los cuestionarios cuando lo resolvéis, ¿verdad? 00:07:01

Me han escrito en el chat que eso, que en los PDFs hay preguntas, pero si te estás refiriendo a los cuestionarios, a los test de evaluación, 00:07:06

tú cuando acabas el test de evaluación, pues vas respondiendo y vas haciéndolos. 00:07:15

Y al final, ¿vale? Y ojo, aquí hay una flecha para ver todas las preguntas si queréis navegar. 00:07:20

Cuando decís terminar el intento, es decir, ya habéis respondido las preguntas y las entregáis, pues ahí te pone, aparte de si están bien o mal, te pone cuál es la correcta, cuál sería la correcta y en ocasiones pone apuntes relevantes para saber por qué no o alguna connotación o algún vídeo en ocasiones, etc. 00:07:24

¿Vale? ¿Hay dudas con todo esto que estoy contando? Lo digo porque, siendo de segundo, lo dije el primer día y en la primera reunión, o al menos lo intenté hacer, vaya, pero bueno, que si hay dudas en este sentido, pregúntadme, ¿vale? 00:07:45

Vale. Me pone, no me refiero al temario, al menos los PDFs que tengo en el primer año que tienen mini cuestionarios vienen con las respuestas. Sí, si en el tema hay algún caso práctico, algún ejercicio, pero en el propio, en los temas, por ejemplo, en DAME, si nos metemos en el tema 4, por ejemplo, que sé que hay alguno, pero lo tengo ahora más fresco. 00:08:03

No sé si es aquí, pero... ¿Cómo puedo entrar de datos? Puede que sea. Vale, pues a veces hay como casos prácticos que te hace una pregunta. A ver, porque lo pongo en ocasiones. Que hay alguna pregunta para que la penséis, la intentéis resolver, pero... Vale, ejercicio de ampliación. 00:08:28

Y te pone como un... te pone un supuesto, ¿no? Para ver la retroalimentación, la respuesta, ¿vale? Pulsáis ahí y la veis. Entonces, aquí también se ve, ¿verdad? Que al imprimirlo te lo suele poner, pero no significa que no esté en la versión, repito, que debéis estudiar. La PDF es de Apoya, ¿vale? 00:08:49

No sé si tenéis alguna duda más 00:09:09

En este aspecto 00:09:15

Sí 00:09:17

Hola a todos 00:09:25

Yo tenía una duda 00:09:27

No específicamente con esto 00:09:29

Las tareas que subimos a compartidos 00:09:31

Cinco días de caducidad 00:09:34

Claro, el problema que tiene compartidos 00:09:37

Y compartidos ya os envía algún enlace 00:09:40

De qué es y para qué es 00:09:42

Que es básicamente para poder subir archivos pesados 00:09:43

Y funciona como un WeTransfer, básicamente te genera una URL con el contenido. El problema, que entiendo que es para que los servidores de Duca Madrid o de la Comunidad de Madrid o donde estén, no se almacene un peso excesivo, es que ponen, y lo vais a ver cuando intentéis hacer uno de estos enlaces, el tiempo máximo de caducidad, de vigencia, mejor dicho, antes de que caduque ese enlace y ya no se pueda descargar nada, es de una semana. 00:09:45

por eso veréis que las entregas 00:10:11

si por ejemplo es un lunes, pondré que el primer día 00:10:13

sea el miércoles anterior, porque si me subís 00:10:16

ese enlace dos semanas 00:10:18

antes, cuando yo vaya a descargarlo 00:10:20

dado que se corrige una vez 00:10:22

ha cerrado el plazo, de pronto puede haber 00:10:24

enlaces en el que no hay nada 00:10:26

precisamente esa era mi duda, porque yo 00:10:27

ya he subido tareas hace 00:10:30

tres días, ponlo tú 00:10:31

y claro, tenía la 00:10:33

inquietud de que si acaso tú lo estabas revisando 00:10:36

constantemente, entonces lo que tenemos que hacer es 00:10:38

esperar una semana, cinco días antes 00:10:40

y subirla. Mira, si os fijáis, eso 00:10:42

ya, digamos que me 00:10:44

entre comillas preocupo yo 00:10:45

de, por ejemplo, la 00:10:47

tarea de la UT4, ¿vale? Y esto 00:10:49

lo hago sobre todo, a mí me toca 00:10:52

módulos en los que las entregas 00:10:53

tienen mucho peso, porque hasta 100 megas te deja 00:10:55

adjuntarlo a la tarea y no habría este problema. 00:10:57

Pero como aquí es muy normal que tenga 00:11:00

más de 100 megas la entrega, 00:11:01

pues este es el método que hay. 00:11:03

Vais a ver que las tareas, si esta se 00:11:05

entrega, ¿vale? La que se abrió ayer 00:11:07

el tema. Se entrega el lunes 10 de marzo 00:11:09

para que podáis 00:11:12

enviar vosotros, donde os va a poner 00:11:14

enviar tarea o algo así, ¿vale? 00:11:15

Va a empezar a estar activo a partir 00:11:18

del miércoles 5, ¿vale? Porque yo este 00:11:20

lunes sí que lo miraré como lo máximo 00:11:21

y os pido además en las instrucciones de que pongáis 00:11:24

una semana, no va a caducar 00:11:26

porque yo el martes, ¿sabes? Según acabe 00:11:27

esto, el martes por la mañana 00:11:30

me lo descargo. Entonces ahí todavía deberían 00:11:31

estar activas todas las 00:11:33

todos esos enlaces de compartidos. 00:11:35

Entonces, no vais a poder entregar una tarea de este tema antes de esta fecha, ¿vale? 00:11:39

Que está ya medida un poco para que yo el martes, todavía no haya pasado una semana desde este miércoles, 00:11:43

y me las pueda descargar, ¿vale? 00:11:49

En las primeras veréis, algunas, las dos primeras, no ponía esta fecha porque no pesaba mucho. 00:11:52

Entonces, pues si la dejabais ahí, pues ya estaba ya en la tarea. 00:11:57

Pero cuando osáis compartidos caducan los enlaces, ¿sí? 00:12:01

Vale, ok 00:12:04

Sí, sí, era precisamente por la primera 00:12:06

tarea que vencía 00:12:08

ahora, ¿no? 00:12:10

Ayer 00:12:11

A mí se me fue un poco la pinza 00:12:11

y claro, me interesaba lo suyo 00:12:15

por eso lo tuve que compartir por el otro lado también 00:12:16

Vale 00:12:18

Pues no 00:12:20

lo que tenéis que hacer es subirlo a compartido 00:12:21

si lo necesitáis usar 00:12:24

y el enlace 00:12:26

esa URL 00:12:28

de la que cualquier persona puede descargar 00:12:29

vosotros también si lo probáis, que es buena 00:12:32

práctica, probar si ese enlace, si lo metéis en el navegador, os abre el área de descarga 00:12:34

de eso que habéis subido, porque a veces enviáis enlaces que no funcionan, y no por 00:12:38

caducidad, sino porque no está bien metido nada, entonces vosotros lo podéis comprobar 00:12:43

si copiáis ese enlace. Pues ese enlace lo copiáis y me lo pegáis en la tarea, en el 00:12:47

cuerpo de texto que hay para las tareas, y yo ya de ahí me lo descargo. Es una dificultad 00:12:53

que tenemos de módulos, eso. Imagino que en ciclos 00:12:59

de contabilidad no pesan tanto las cosas, pero nosotros entre que trabajamos con vídeos 00:13:03

o trabajamos con archivos pesados, pues 00:13:07

tenemos estos problemas. ¿Vale? Más cosas. 00:13:11

Vale, pues voy a abrir la consulta que 00:13:24

he visto en el foro, que es, bueno, acabo de ver una 00:13:27

en Dane UT4, PDF. Buenas tardes, 00:13:31

No soy cabal de imprimirme la práctica. 00:13:35

Última, cuatro, gracias. 00:13:37

Si tenéis que imprimir algún apartado que no está ya en ese PDF 00:13:39

porque no es de los contenidos, aquí están los contenidos solo. 00:13:41

Pero, por ejemplo, queremos el enunciado de la tarea en PDF, por lo que sea. 00:13:45

Si le dais, o debería ser, si os metéis en el área, 00:13:49

dais clic derecho e imprimir, con lo que os he dicho de guardar Adobe PDF, 00:13:52

vale, exactamente, no deja porque no muestra todo. 00:13:57

Vale, en principio las tareas 00:14:02

Por recomendación 00:14:06

Vamos, por cómo está organizado 00:14:07

El tema 00:14:09

No se pueden imprimir, no las damos impresas 00:14:10

Mejor dicho, y por cómo está en la plataforma 00:14:13

Pues no permite 00:14:15

La solución que os puedo dar a este respecto 00:14:16

Vale, es 00:14:19

Que hagáis zoom con el navegador 00:14:20

Podéis irlo haciendo más grande 00:14:22

Entonces podéis ir ampliando 00:14:24

Con el navegador 00:14:27

A nivel de zoom que tenemos aquí 00:14:28

y podéis ir haciendo más 00:14:31

más grande y más pequeña 00:14:34

de todo modo si tenéis 00:14:35

digo hasta ahora en los tres años que llevo 00:14:37

no he tenido este problema 00:14:40

si alguien tiene problema 00:14:41

con los textos, etcétera, pues vemos una solución 00:14:42

¿vale? pero en principio está pensado 00:14:46

para que se vea de este modo 00:14:48

luego hay 00:14:49

si no me equivoco 00:14:53

hay otra opción 00:14:55

que es 00:14:56

A ver, en esta página no está disponible. Esto estoy improvisando a ver si se puede hacer de algún modo, pero es verdad que justo en estos no. 00:14:57

Si no, a partir de ahora, lo que puedo ir haciendo es, aunque aquí no lo hacía porque en principio pensaba que nadie tenía este problema, es poner también la barra de ampliación y que podáis cambiar también los tamaños de textos, etc. 00:15:12

Pero ya os digo, en nuestras instrucciones no está previsto que convirtamos todo a PDF, porque supone diferentes problemas. Y además que las tareas, por ejemplo, si tienen un vídeo, etc., no se pueden ver en ese PDF. 00:15:29

Pero, teniendo en cuenta, para siguientes, lo que sí puedo es estos Excel Learning, que es un formato que usamos nosotros, le ponemos esta barra avanzada de poder aumentar las medidas, etc., del texto. 00:15:42

Y vamos a la que tengo aquí pendiente 00:16:00

Y os la voy a resumir para contarla rápido 00:16:09

Porque tampoco quiero que pasemos mucho tiempo 00:16:12

Y bueno, una compañera me ha escrito básicamente 00:16:14

Que buenas tardes, planteo una duda 00:16:18

Ya que mañana no podré asistir a la tutoría 00:16:21

Bueno, he tenido el mismo problema 00:16:23

Y básicamente tiene un problema en la unidad 2, en la tarea 00:16:24

que es que tiene un elemento que está instanciando los obstáculos, ¿no? Recordemos que básicamente en esta tarea tenemos esta nave que se va moviendo, etcétera, y bueno, puede rotar, etcétera, ahora vemos algunas posibilidades, 00:16:27

pero que llega un momento que no se siguen instanciando estos obstáculos, ¿vale? 00:16:45

Ella indica que tiene, igual que yo, de otra forma, pero ha llegado a la solución correcta, 00:16:51

tiene un código que sirve para instanciar, igual que hacíamos en la primera tarea, 00:16:56

que sirve para instanciar un obstáculo que está capturando, por este sería el Icefield, 00:17:01

como un GameObject, ¿vale? Igual que hacíamos en la primera tarea, y lo tiene ahí. 00:17:09

¿Qué problema está teniendo? Importante, porque es verdad que esto se olvida a veces rápido, pero es que ella ha puesto que el GameObject, que es instancia, que está juntando aquí, no es el prefab en sí, no es este prefab que tenemos en el área de proyecto, sino que lo que ha incorporado es que ella metió un obstáculo ya para tenerlo aquí de referencia, imagino, y dijo, este es el obstáculo, me pongo un instanciador, 00:17:12

Y este es el obstáculo que lo ha arrastrado y parece el mismo. Pero ¿qué problema hay? Que ella, en cierto momento, con todos los obstáculos, dentro del script del obstáculo, se está moviendo y también se destruye a sí misma, que es lo que se pide con la función destroy. 00:17:40

¿Qué pasa? Que como el instanciador está cogiendo este obstáculo de la jerarquía, si yo doy play al juego, vais a ver que se están reproduciendo los obstáculos y en cuanto se destruye, ahora está ya otro, aquí no aparece. 00:17:56

Es decir, se ha perdido porque se ha borrado ese obstáculo que teníamos en la jerarquía, que es este que está cogiendo como referencia, y cuando se destruye, porque es cuando pasa la cámara, donde lo he configurado se ha destruido, solo ha dado tiempo a hacer un clon, una instancia, y aquí de pronto aparece este mensaje de missing y ya no sabe que seguir instanciando y ya no hay copias, ¿vale? 00:18:14

Es la diferencia con, si yo borro y a este instanciador le digo que sea este obstáculo, que al estar fuera de la jerarquía, ¿vale? Está como en un nivel superior porque está en el proyecto, pues yo si arrastro este, este nunca se va a borrar, ¿vale? Fijaos que yo me estoy fijando aquí en obstáculo, no está en ningún lado, pero se están haciendo estas copias, ¿no? 00:18:35

en el tiempo, con la corrutina 00:18:54

como está pedido en la tarea 00:18:56

pero este obstáculo 00:18:58

aquí no se borra, por tanto siempre 00:19:00

el instanciador va a tener la referencia de qué objeto 00:19:02

instanciar 00:19:05

¿vale? Creo 00:19:06

y eso es lo que os comento, que a veces por el foro 00:19:08

pues no tengo todos los detalles 00:19:10

¿vale? Dentro de todo esto 00:19:13

que me ha enviado, pues por ejemplo 00:19:14

me envía indicaciones 00:19:16

bastantes imágenes y por eso lo he podido deducir, lo he hecho bien 00:19:18

pero me falta información de 00:19:20

Yo no sé este obstáculo si es el del prefab o es el de el que tenemos aquí, ¿vale? Y de hecho lo tiene marcado porque es el que desaparece y por tanto es el que ya no puede generar, no se pueden generar más instancias porque aquí pondrá un missing object, ¿vale? Bueno, pues es el que está dándole el problema, ¿vale? Entonces, bueno, que a veces es complicado dar con el motivo, pero entiendo que es ese, si no, pues ya me lo dirá la compañera, ¿vale? 00:19:22

La tarea, los que os habéis puesto a hacerla. La tenéis enfocada. La estáis resolviendo. Algún problema concreto. El último día sí que vimos ya bastantes pautas. 00:19:48

Vale, hay gente que ya me está poniendo 00:20:04

La tengo terminada, entregada 00:20:08

Vale, quiero que veamos un par de cosas 00:20:09

Bueno, pone 00:20:12

Un compañero, tengo que pulir porque tengo algún código alternativo 00:20:13

Para hacer pruebas, exacto 00:20:16

Eso es muy habitual, es decir 00:20:17

Y os lo digo así 00:20:20

Este módulo, vamos, las tareas 00:20:22

Se pueden llegar a soluciones 00:20:24

A la misma, además, e igual de válidas 00:20:26

Esto creo que ya lo he dicho 00:20:27

Por diversos caminos, incluso podéis tener 00:20:28

Varias formas de resolverla 00:20:32

Mira, por ejemplo, fijaos en este código que yo tengo aquí. Este es el que acabo de abrir. Dame un segundo que me organizo las pantallas. Este no es el que me interesa ahora, pero por ejemplo, la nave lo estoy moviendo ahora mismo con este código. 00:20:34

Y si os fijáis, tanto por probar o porque tengo varios, uno por ejemplo, os voy a contar ahora, ¿vale? Les comento uno y comento otro. Yo tengo aquí distintos métodos. No sé por qué aquí me ha dado error ahora, no debería. Ah, bueno, sí, porque aquí me falta otra línea de comentario. 00:20:52

Yo voy viendo que aquí tengo un montón de métodos preparados 00:21:10

Pero cuando sale además con esta palabra en gris 00:21:17

Vamos, en gris, es amarillo pero está como sombreado 00:21:21

Significa que no está usándose 00:21:24

Pero yo tengo este código aquí preparado 00:21:25

Por si lo quisiera usar 00:21:27

E incluso veréis que cuando tenéis un script 00:21:29

Y fijaos también en el número de las líneas 00:21:32

Tenéis hasta flechitas para reducir 00:21:34

para ir compactando estos scripts. 00:21:39

Así de primeras a lo mejor no es lo más óptimo, 00:21:42

pero si dice, vale, estos no los estoy usando, 00:21:44

pero los quiero aquí. 00:21:46

Fijaos que hay saltos de línea y los habéis encogido. 00:21:46

Estos son códigos que yo tengo aquí comentados 00:21:49

porque no quiero usar, 00:21:51

porque a lo mejor los he probado y no me funcionan, 00:21:52

o porque es una funcionalidad que no tengo claro 00:21:54

si va bien o si la voy a usar. 00:21:56

Bueno, yo puedo tener un montón de métodos, 00:21:58

por ejemplo, aquí preparados. 00:22:02

Entonces podéis comentar y llegar de distintas formas. 00:22:03

Así que es verdad que para las entregas intentad dejarme la solución sin mucha, lo voy a decir así rápido, morralla, porque si no me vuelvo loco de qué estáis intentando entregar. 00:22:07

Y otra cosa importante es en las tareas, y vais a ver que ya son amplias y se piden muchas cosas, os pido por favor que intentéis resolver lo que se os pide en la tarea. 00:22:19

Luego vosotros si queréis complicarlas todo lo que queráis o seguir, pues por supuesto hacedlo. 00:22:27

Pero de cara a la tarea, no uséis, por ejemplo, si se pide el input manager, no uséis el input system que es bastante más complicado. 00:22:31

El input system, por ejemplo, se explica para que lo conozcáis y porque es relevante. 00:22:39

Pero con todas las cosas que hay que dar, no es asumible pasar mucho tiempo con el input system. 00:22:43

Y si no, ya lo haremos cuando acabemos, digamos, en los últimos impases. 00:22:49

Pero hay tantas cosas que vamos a ir a por lo que hay que sacar, ¿vale? Que no es poca cosa. Entonces, lo dicho, a veces se puede llegar al mismo camino por distintos. Y el último día, ¿vale? El rotar nave, lo que os dije, bueno, lo que se puede hacer es, bueno, más que rotar nave era, la que puse era rotar nave y fijar. 00:22:54

Bueno, aquí tenía otra preparada 00:23:17

Pero esta creo que no 00:23:20

Es que hay bastantes cosas que os podría comentar 00:23:22

Más complicadas y tampoco me quiero 00:23:25

Complicar 00:23:26

Porque quiero pasar a la 3 00:23:29

Y no es relevante, ¿vale? 00:23:30

El otro día, entiendo que todos los que lo habéis hecho 00:23:31

Lo que habéis 00:23:33

La que le estáis entregando, la que le estáis acabando 00:23:34

Básicamente lo que habéis hecho es usar 00:23:37

El método rotate del transform, ¿vale? 00:23:38

Como aquí, ¿vale? En base al eje Z 00:23:40

Porque dijimos que gira en base a ese 00:23:42

Eje, ¿vale? 00:23:45

Entonces, pues rotará hacia los lados realmente con el eje Z. Y bueno, pues con lo que se va capturando de los inputs, ¿vale? Que ya, bueno, pues hablamos de los axis y cómo crearlo y ese menos uno y uno como límites de un eje entre un valor positivo y negativo para transmitir esa información, ese dato a, por ejemplo, a un cambio de posición o de rotación, ¿vale? 00:23:47

Esto era una forma de hacer que la nave rotara. Y de hecho, yo si comentara todo esto hasta aquí, y este es el método que estoy usando, ¿vale? A ver, aquí lo tengo y debería estar comentando hasta ahí. 00:24:12

Ah, vale, es que tengo aquí abierto otro. Voy a cerrarlo también. No quiere. Espera, aquí en vez de poner una estrellita voy a poner esto y tampoco quiere. 00:24:32

No puedo colocar en el comentario de bloques 00:24:44

Dentro del comentario de bloques 00:24:47

Vale, esperad un segundico 00:24:48

Ahí está 00:24:53

Vale, entonces 00:24:55

Con este rotate básicamente 00:24:57

Yo cuando, bueno si guardo 00:24:59

Etcétera, el problema que tenemos 00:25:01

Bueno, es decir 00:25:03

A ver que me ha puesto 00:25:03

Vale, me habré cargado 00:25:07

Alguna cosa, esto es lo malo 00:25:10

Pero básicamente 00:25:12

Exactamente. Vale, aquí. Entiendo que hay alguna llave que no he cerrado. O mejor dicho, que sobra. 00:25:14

Bueno, cierro esto. Bla, bla, bla. Vale, y aquí. Es que ir explicando a la vez que os hablo no es a veces la mejor idea. Está complicado. 00:25:25

Baja, baja, baja. Ahí te sobra un paréntesis, el anterior. En la 135. 00:25:43

135. ¿Este? Ah, vale, perfecto. Vale, sí, que estaba ahí. Venga, genial, muchas gracias. Pues, vale, básicamente lo que hemos conseguido ahora, y es una buena solución, ¿vale? Porque cumple lo que estábamos diciendo, es que esta nave, si le doy hacia, que rota hacia la derecha, pues rotará indefinidamente. Si doy a la izquierda, rota indefinidamente también. 00:25:50

Y además, como el transform lo hemos puesto, recordad, el translate, ¿verdad? Como que use el espacio, ¿vale? El mundo en vez de el self. Recordad esto que teníamos por aquí, ¿vale? Que el space sea el world y no el propio objeto en sí, pues da igual lo que giremos, que siempre la arriba va a ser la arriba del mundo o el abajo del mundo, etc. ¿Vale? 00:26:11

¿Qué ocurre? Que a lo mejor, y yo en mi planteamiento seguramente sería este al hacer el juego 00:26:35

Es que la nave rote hasta este punto o hasta este punto, ¿vale? Y no pase de ahí 00:26:41

¿Qué ocurre? Que no estamos haciendo ningún límite para que esto deje de hacerlo así 00:26:46

Entonces ahora la nave de pronto la podemos poner boca abajo o boca arriba o como nos dé la gana 00:26:50

Porque rota indefinidamente y ya está, ¿vale? 00:26:54

Aquí no se pedía explícitamente que limitáramos esos movimientos 00:26:58

pero os quería contar un par de cosas sobre cómo se podría hacer, porque también nos da, bueno, pues ideas de cómo podríamos hacer esto, ¿vale? 00:27:03

Voy a descomentar esto, que tantos problemas me ha dado, ¿vale? Está ahí. Luego os hablo de esta fórmula, ¿vale? 00:27:11

Pero os voy a comentar, os voy a poner la otra, que es una muy simple realmente, y vais a ver que, a ver, otra vez me ha pasado lo mismo, 00:27:18

Y bajo, bajo, bajo 00:27:27

Tienes que añadir ahora 00:27:28

Y aquí la tengo 00:27:30

Vale 00:27:34

Ahora mismo he activado 00:27:35

Otro método que tenía aquí de rotar nave 00:27:37

Que si bajamos, hace una cosa muy simple 00:27:39

Y que 00:27:41

Vais a ver como funciona 00:27:42

Lo que estoy consiguiendo es 00:27:44

En el update, recordad que esto está dentro del update 00:27:46

Voy a ampliar esto para que se vea más 00:27:49

Y un segundo 00:27:51

Vale, perfecto 00:27:53

En el update 00:27:54

Lo que estoy diciendo es que, y recordad que los ángulos en Unity, si usáramos lo que a priori sería lo lógico, que es un parámetro que se llamara rotation, igual que hacemos position, si usamos rotation, y bueno, lo pone en el propio tema, etc., está usando esta clase quaternion que se basa en cuatro ejes, que es poco comprensible para el ser humano, aunque tiene su explicación de uso, etc. 00:27:55

Y nosotros nos deberíamos ceñir más a lo que son los ángulos Euler, que se basan en grados, en degrees, y se basa además en tres dimensiones. Hace una traslación, si me meto en el transform, nuestra forma de entender la rotación en los software de 3D, etc., se basan en estas tres dimensiones. 00:28:21

entonces, digamos que lo que hacemos aquí es decir, vale, pasamos, entre comillas, 00:28:41

queremos que la traslación del quaternion la usemos dentro de esta forma que nosotros sabemos usar, 00:28:52

que son estos tres ejes de X y Z, y le vamos a decir, básicamente, que la posición o el valor que tengan estos ángulos Euler 00:28:58

recojan un vector nuevo que estamos creando en ese momento 00:29:06

que no interfiera, es decir, que siempre mantenga en cero 00:29:09

la rotación de X e Y 00:29:13

porque no nos interesa, porque la nave no va a inclinarse hacia abajo 00:29:15

ni hacia, no sé cuál sería el otro eje 00:29:18

hacia, bueno, pues 00:29:22

que haga, digamos, que haga un derecha-izquierda 00:29:24

en el sentido de que lo haga en torno al eje Y 00:29:29

entonces, el que nos interesa en esta práctica 00:29:30

porque lo que estamos pidiendo es que rote en torno al eje Z, ¿verdad? Entonces, podemos decir, vale, lo que vamos a hacer es poner un rotate data, que básicamente es este input axis, 00:29:34

que puede dar como máximo 1 o menos 1, recordad, ¿vale? Según los dos extremos, y multiplicarlo por 90 o por menos 90. Bueno, podría ser 90 o menos 90, cuando se invierten a veces los valores es simplemente 00:29:45

porque el eje ya es o positivo o negativo, si vemos que va en la dirección contraria a la que nos interesa, 00:29:58

como al final esto lo que está dando es valores de rotación que queremos que vayan hacia un lado 00:30:05

que es positivo o negativo, aunque esto luego voy a contar que tiene trampa, ¿vale? 00:30:08

Va entre o a 90 o a menos 90, ¿no? Entonces, si es 1, pues será menos 90, si es menos 1, será más 90, ¿no? 00:30:13

Y, bueno, pues si ponemos este menos es porque nos interesa invertir la dirección, simplemente. 00:30:21

¿Qué significa esto? Que si pulsamos en un teclado, que además en un teclado, como ya hemos hablado, no es como un gamepad, un joystick, que tiene un recorrido entre el 0 y el 1 en esa mitad del eje, sino que es pulsar una tecla y es de pronto 1, de pronto 0 o de pronto menos 1, si es la del eje negativo, pues de un momento a otro, porque esto es en el update, de un fotograma al siguiente, de pronto se encuentra que es o más 90 o menos 90. 00:30:25

Si ahora tengo activado este RotarNave, y os vuelvo a decir, si veis que está el nombrecito en amarillo vibrante, significa que esto lo está usando algún punto del código. Si tenemos aquí preparado y está así desvanecido, significa que está preparado, está planteado este método, pero no se está usando. 00:30:50

problema y beneficio 00:31:11

que hemos encontrado con esta solución de una línea 00:31:14

ahora sí que conseguimos que la nave 00:31:16

solo, y le voy a dar a play 00:31:18

y lo vemos, la nave solo va a 00:31:20

rotar hacia un lado 00:31:22

suelto, cuando suelto, como no estoy 00:31:24

dando ni más uno ni menos uno, sino que es cero 00:31:26

se vuelve a su posición estática 00:31:28

¿vale? y fijaros en el Z 00:31:30

en la rotación de Z, si yo giro 00:31:31

hacia la izquierda, pues es 90 00:31:34

suelto, es cero 00:31:35

doy al botón de la derecha 00:31:37

y a menos 90, ¿vale? Lo que no hay es valores intermedios. Hace esto, que es así, de rápido. ¿Qué pasa? Que hay una forma, y así también entendéis este concepto, 00:31:40

hay una forma de, digamos, al pulsar un input, aunque sea una tecla que da un valor de 1 o menos 1 repentino, recordad, y si veis los apuntes lo pone, 00:31:50

que cada uno de estos, ¿vale? Y esto recordad que para llegar a esta ventana donde se configuran los axis era en Edit, Project Settings y el Input Manager, ¿vale? 00:32:00

Porque estamos usando este en estos momentos. 00:32:09

Tenemos uno, no que crea yo, porque es el que me interesaba, 00:32:14

que fuera específico de esto, ¿no? 00:32:17

Que era el rotador, el eje que recogía este rotate data, ¿vale? 00:32:19

Que yo lo he creado y le he dicho, vale, cuando pulso, 00:32:24

yo he puesto estas teclas, cada uno puede poner las que considere, ¿vale? 00:32:29

Aunque, bueno, poner unas lógicas también para un juego, ¿vale? 00:32:34

Yo, si pones la mano derecha en la U y la I, más o menos tienes espacio para la cruceta del WAS y para la rotación, ¿no? Para esta rotación en este caso. Valor negativo para que vaya a la izquierda la U, para que vaya a la derecha la I latina, ¿vale? Y tenemos estos valores de gravity y sensitivity, ¿vale? 00:32:37

Y si nos ponemos encima es, por un lado, la sensibilidad, mejor dicho, que tiene el input según se pulsa hasta que llega a su valor máximo, que sería este 1 o más 1, más 1 o menos 1, ¿vale? Y hay de 1000, es súper rápido. Pero eso no significa que yo este valor no lo pueda cambiar. 00:32:54

esto significa que si yo le digo vale que la sensibilidad sea de 5 yo que sé 00:33:13

vale y lo pruebo ahora vais a ver que yo desplazo esto para que no esté aquí 00:33:18

molestando le doy al play que va a llegar a ese más uno y menos uno vale de 00:33:24

una forma progresiva al soltar veis que vuelve al volver a relajar y que sea el 00:33:30

cero vuelve inmediatamente pero veis que con esto ya hemos conseguido que los 00:33:34

valores máximos y mínimos, sea porque aunque sea una tecla el input, haya un cierto periodo de, digamos, de interpolación, no es la palabra, 00:33:38

de recorrido hasta llegar a ese punto. Lo mismo pasa, si lo alteramos aquí, con la contraria que es al soltar cuánto tiempo vuelve a la situación de origen. 00:33:48

Si yo en gravedad pongo 5, por ejemplo, un valor mucho más pequeño que este 1000, lo que vamos a conseguir es que aparte de que cuando giremos haya esta interpolación, cuando soltemos y vuelva al valor neutro, porque ahora hay un valor neutro de 0 cuando no estamos pulsando nada, veis que vuelve a ese valor relajado. 00:34:02

Entonces, bueno, aparte de subir, bajar, ir a la derecha, etc., pues tiene esta interpolación y, ojo, tiene unos límites. Ahora no hace este giro continuo que teníamos en la anterior opción. Esto siempre es según lo que se busque. A lo mejor en el juego quiero que la nave rote sin parar, pero bueno, es una forma también para que veáis que aunque usemos teclas, hay valores relacionados con que no sean repentinos estos inputs. 00:34:22

Perdón, oigo un micro por ahí abierto. A ver, perdón, creo que es... Sí, cerrad el micrófono, porfa. Vale. Pone un compañero, ¿puedes usar una variable serializada para seleccionar qué método usar? 00:34:52

Sí, sí, sí, se pueden hacer muchas cosas 00:35:12

Esto es lo de siempre 00:35:14

Y yo no lo voy a ocultar 00:35:16

Yo no soy programador 00:35:17

No tengo formación en ello 00:35:18

Entonces mi idea es explicar los conceptos básicos 00:35:22

Para que estén lo más claro posible 00:35:25

Y se pueda abarcar mucho de lo que vamos a usar 00:35:27

¿Vale? 00:35:29

Todo se puede complicar muchísimo más 00:35:30

Entonces lo digo porque en ocasiones 00:35:32

Todo puede hacerse mucho más avanzado 00:35:35

Pero dado que es un poco introductorio 00:35:37

a gente que no sabe de código, lo digo porque entiendo que habrá gente aquí que sabe más, 00:35:40

nos vamos a intentar restringir un poco a lo que se va explicando a los temas, 00:35:45

que es una introducción creo bastante completa. Lo digo porque siempre hay varios ritmos 00:35:51

y hay gente que le cuesta muchísimo salir de curso y otra gente que, bueno, pues que al contrario, 00:35:57

que lo tiene súper asumido. Entonces hay que navegar un poco entre esas dos aguas. 00:36:04

Esto es una solución para llegar a estos límites máximos usando esta suavización de los inputs. 00:36:09

Hay otra solución más compleja, por ejemplo, otra alternativa, y aquí es donde voy a comentar este método y voy a poner esto de rotarNave y fijar, que es la que antes había comentado. 00:36:27

Que básicamente es seguir empleando, por poner un valor que hemos creado aquí una variable para que sea más o menos rápida, este rotate. Solo que se han añadido unas cuantas líneas más para que ese rotate también tenga una limitación de esa rotación. 00:36:40

Y esto lo voy a explicar para que veamos la trampa que tienen estos Euler angles, porque al final lo que estamos variando a veces, aunque estemos viendo una cosa en el inspector, cuando vemos aquí esta nave que vaya girando en Z, realmente la traslación de los Euler angles no es tal. 00:36:58

Me explico, yo si cojo esta nave y empiezo aquí a girarla con el inspector y empiezo a girar, a girar, a girar, veis que hay valores que superan los 360 grados que tiene una rotación completa. 00:37:20

¿Y qué es? Pues que cada 360 grados básicamente está volviendo a empezar otra vez la rotación. Creo que hasta aquí es lo que ya sabemos y del mismo modo en negativo, que rotará en la otra dirección. 00:37:31

¿Qué ocurre? Que si yo, y esto también para que lo tengamos claro, si yo llego a este punto, que estoy haciendo esta rotación de la nave, y le digo, voy a crear otra variable, un float, que coja la rotación actual de esta nave, 00:37:43

que básicamente es de este objeto, la nave, voy a coger el valor del eje Z, que es el que estamos cambiando y el que nos interesa, en su valor de ángulo seuler. 00:38:00

Y justo a continuación, esto de momento lo omitimos, pero justo a continuación vamos a ver el valor que está mostrando esto. 00:38:12

Y vais a ver que no es concordante siempre. Bueno, voy a comentar de hecho esto que tenemos aquí. Vale, hasta aquí. Bueno, a ver, hasta aquí, hasta aquí, hasta aquí. 00:38:20

Ahí lo tenemos. Tenemos estas líneas, en principio está bien, guardo y vamos a ver que yo cuando vamos mostrando ese eje Z simplemente en la consola, yo empiezo a dar aquí y veis que si yo pongo aquí la nave prefab, 00:38:35

Aquí pone Z menos 61 y sin embargo si vemos la consola pone 298 y vais a ver que este valor siempre está entre el 0 y el 360 mostrando una rotación de una sola vuelta y yo sigo haciendo esta rotación. 00:39:13

veis que nunca es negativo el valor y aquí sí estamos viendo negativos. ¿Qué significa? Que aunque en el inspector no lo muestre con valores negativos, realmente en el código 00:39:33

y como está funcionando por debajo esto de los ángulos Euler es siempre en un valor que muestra entre el 0 y el 360 en positivo. Esto implica muchas dificultades porque si, por ejemplo, 00:39:43

yo quiero decirle que esta nave me la mueva al menos 4, si yo lo pongo menos 4, realmente por detrás lo que está gestionando es un 356, que son los 360 menos los 4. 00:39:55

Entonces, si yo quiero girar la nave con algo que sea directamente usar los ángulos Euler, manipulando estos valores directamente, hay que hacer operaciones intermedias o conversiones para que esto no dé problema. 00:40:11

Porque si ponemos valores negativos, lo que va a hacer es saltar directamente al final del recorrido del siguiente, ¿vale? Porque pasará de 0 a 200, a 350 y pico, yo que sé, y va a haber saltos y va a haber problemas y para limitar también pueden surgir ciertos inconvenientes, ¿vale? 00:40:26

Por eso os doy aquí un planteamiento, hay más, etcétera, ¿vale? Que quiero comentar para que veáis también el uso que se puede dar a este operador módulo del que hablamos el otro día, ¿sí? 00:40:44

Entonces, lo que esta línea ya, por ejemplo, bueno, la voy a dejar ahí que en todo momento nos enseñe el valor del angular Euler de z según estamos haciendo esta rotación, ¿vale? 00:40:57

Pero lo que vamos a hacer es esta operación, que de primeras puede costar, pero es esta variable de current rotation, que en su momento valía este valor, siempre positivo, hemos dicho, de 0 a 360. Voy a hacer que se guarde y opero, que esto se puede hacer también. 00:41:08

Es algo que vimos cuando se usaba la suma, por ejemplo, que se podía hacer este current rotation es igual a current rotation más uno, ¿vale? Recordad que se puede operar, esto es un ejemplo, se puede guardar en una variable un valor que apele a esa variable y luego más operaciones aritméticas, ¿vale? 00:41:25

Que a veces parece un poco intuitivo decir, current rotation es igual a current rotation extrajosa, ¿vale? Lo que está haciéndose aquí es guardar un contenido que estamos designando aquí y estamos apelando en este momento, en el que todavía no se ha guardado, está en esa operación, este valor que se había puesto. 00:41:45

Entonces, imaginaos que yo he rotado 4 a la izquierda, ¿vale? Ese menos 4 que se ve en el inspector, pero que a nivel interno el código realmente aquí está viendo reflejado como un 356, ¿vale? 00:42:02

¿Qué es lo que vamos a hacer aquí? Poner siempre que este valor sea mayor a 360, ¿vale? Es decir, si yo tengo una current rotation, bueno, en realidad no es que sea siempre mayor que 360, es que esté en un rango, ¿vale? Que se mueva entre 180 y menos 180. 00:42:17

¿Qué conseguimos aquí? Que este valor que tengamos aquí, al dividirlo entre 360 y dar el módulo, básicamente estoy diciendo qué grados hay en una sola vuelta. 00:42:40

¿Por qué? Porque si, por ejemplo, habíamos hecho que en este valor fuera en vez de menos 4 menos 364, ¿vale? Como hemos dicho que los ángulos Euler solo operan en un giro, es decir, de 0 a 360 y no pasa de ahí, ¿vale? Pues al hacer este módulo estamos diciendo, oye, al dividirlo entre 360, ¿cuántas vueltas hemos dado? 00:42:52

Entonces se le suma a ese ángulo estos 180, se divide ese valor entre las vueltas que puede tener y luego esa compensación, es decir, esos 180 que se habían contado, 00:43:14

al final el resultado de esto puede ser 0, 1, 2, que es el número de vueltas, que es lo que estamos consiguiendo con esta operación. 00:43:28

Si es positivo, se estabiliza con esto para que llegue a cero. 00:43:35

Si, por ejemplo, hemos girado 180, ¿vale? 00:43:39

Y al girar 180, le sumamos 180 y lo unimos entre 360, el módulo va a ser cero. 00:43:42

Y al restarle este 180 se va a quedar en el valor negativo. 00:43:49

No sé si me estáis siguiendo, pero con esta operación lo que estamos haciendo en todo momento es compensar, ¿vale? 00:43:54

el número de vueltas que hay y también restringir que los valores que dé esto sea entre menos 180 y 180. 00:43:59

Porque si tiene el valor máximo, que va a ser 0, va a dar menos 180, ¿vale? 00:44:08

Y si está entre 159, cuando se le reste 180, pues va a estar en los valores positivos del comienzo del giro, digamos. 00:44:16

Básicamente, si yo me meto ahora en el código, y esto me sirve sobre todo para hablaros de estas discordancias que hay entre el eje Z y lo que va mostrando la consola. 00:44:26

Vais a ver que está todo el rato, a ver, aquí lo voy dando, va a estar en todo momento yendo entre los valores de 180 positivos y luego automáticamente pasa a menos 180. 00:44:37

Y una vez tenemos esto preparado, lo que podemos ir haciendo y haberlo convertido ya a una rotación que va entre menos 180 y más 180, que no es lo que hace por defecto los Euler angles, sí que podemos crear otras variables y poner unos límites nosotros, que es menos 90 como máximo de giro hacia la izquierda y más 90 de máximo de giro a la derecha. 00:44:49

Y con esta conversión hecha entre 180 y menos 180, es decir, si esta rotación es menor al mínimo o mayor, recordad que este operador de las dos líneas es una condición o la otra, o mayor a estos 90 grados, es decir, dicho de otra manera, si sale dentro de los rangos que queremos definir aquí, 00:45:12

Y lo que vamos a hacer es decir que esta rotación, este valor que puede estar por encima de 90 o de menos 90, si está en alguna de esas dos situaciones que se sale del rango que queremos, vamos a limitarlo y vamos a hacer que este giro se encuentre dentro de unos límites. 00:45:34

Para ello, este método no está en los contenidos 00:45:58

Esto es de ampliación lo que os estoy contando todo 00:46:02

Hay una operación, un método que se llama el MathF 00:46:05

Que es una clase que hay en Unity para operaciones matemáticas 00:46:08

Y este clamp que significa, o sirve, o se usa 00:46:17

Si lo buscamos en el navegador, si decimos que nos diga que es el clamp Unity, nos metemos, dice que existe esta clase, que si nos fijamos con esto se puede dar el valor que tengamos o que queramos evaluar 00:46:22

Y queremos que lo que devuelva este método sea siempre o esté limitado a un número mínimo o a un número máximo. 00:46:50

Es decir, que aquí ahora mismo, si estamos pasándole una rotación de 0 o de 10 o de 50 o de menos 50, como está dentro de los mínimos y máximos que estamos marcando en los otros dos argumentos, 00:46:59

pues no lo va a cambiar, pero si este valor de pronto valiera 180 o 150, porque se sale del máximo que hemos marcado, lo pondrá en el máximo, es decir, lo restringirá a ese máximo, lo dejará que como máximo de aquí salga un valor de 90 y como mínimo uno de menos 90 y lo guarda en current rotation de nuevo. 00:47:13

Daniel, pero entiendo entonces que está de más el IF anterior. 00:47:38

¿no? porque el clamp 00:47:43

ya te lo va a dar el valor 00:47:45

que corresponda, sin el if 00:47:47

el problema que hay si quitamos 00:47:49

este if, ¿vale? es que 00:47:52

estamos en todo momento llegando a 00:47:53

este math clamp, realmente 00:47:55

vamos a probarlo, vamos a probarlo 00:47:57

puede que lleve razón 00:48:00

y lo dejar ahí porque 00:48:02

es que te lo ponía ahí 00:48:03

la definición que te daba el valor si es que no se pasa 00:48:05

a ver 00:48:08

pues aquí y aquí 00:48:09

efectivamente, si que 00:48:11

verdad que a veces yo creo que es bueno poner algún if de control para que no se 00:48:13

meta a hacer otras operaciones pero es verdad que lo poquito que tiene aquí 00:48:17

tampoco hace mucho sí que esto puede venir de que en vez de hacer 00:48:19

con un roteo menor vale si hacemos esta operación y la 00:48:26

invertimos realmente vale 00:48:31

pero aquí si hacemos esta operación lo que sí podemos hacer es limitar los 00:48:35

ángulos, porque decimos 00:48:41

esto es igual que lo de los límites 00:48:43

que pusimos 00:48:45

el otro día, bueno y lo puse en un comentario 00:48:47

de marcar si los límites es verdadero 00:48:48

que entonces si se ejecute un movimiento en base a 00:48:50

límites de posición 00:48:53

que hemos puesto, etcétera 00:48:54

hay un comentario 00:48:56

del foro que entiendo que habréis visto 00:48:59

resolviendo una duda que explica un poco como hacer 00:49:00

la parte de los límites, por eso no me estoy metiendo 00:49:03

mucho aquí, pero 00:49:05

si hacíamos esto 00:49:06

básicamente 00:49:08

también se limita a más 90 00:49:10

y a menos 90 00:49:16

bueno, espera, porque 00:49:17

si curro en rotation es 00:49:18

claro, el problema que hay aquí, nuevamente 00:49:20

es un AND en vez de un NO 00:49:25

efectivamente, eso es 00:49:28

si lo ponemos como AND 00:49:29

ahí lo tenemos 00:49:30

la condición se está cumpliendo 00:49:34

el problema es que cuando 00:49:37

y esto también es importante a la hora de hacer rotaciones 00:49:38

cuando llegamos a uno de los límites 00:49:40

bueno 00:49:42

es que el problema está aquí si es mayor a la rotación mínima y menor para aquí menor a la 00:49:42

máxima ahora ya creo que sí vale ahora sí que va a decir vale cuando sobrepase el mayor el máximo 00:49:51

el mínimo lo está haciendo ahí pero da a otros problemas si la curren rotation que va entre 180 00:49:59

y menos 180, porque es lo que hemos definido aquí, ¿vale? Lo que sale de aquí. Si es mayor de la mínima, ¿vale? Y menor de la máxima, ¿vale? 00:50:10

si se hace se hace esta transformación vale pues después pues eso es si debería hacer este cambio 00:50:27

y hacerlo efectivamente he guardado está aplicado si está todo bien guardo otra vez y si voy aquí 00:50:38

y lo giro y no tengo otro método por ahí girando no pues entra este conflicto que 00:50:48

es que básicamente, y el problema vendrá por ahí, ¿veis? No sé si lo notáis, se anota en el primero, 00:50:56

da un pequeño salto cuando llega a ese menos 90 y más 90. ¿Por qué? Porque de la inercia que tiene, 00:51:03

se pasa de ese 90 y de ese más 90. Entonces, al pasarse otra vez, entra en el siguiente ciclo, 00:51:08

y creo que ya vuelve a entrar otra vez en la condición. No, en realidad lo que estoy diciendo no lo tengo muy claro, 00:51:15

que sea así pero no está funcionando vale entonces vuelvo otra vez a asegurármelo con esta condición 00:51:23

que ya de primera pone una una condición para acotar un poquito y luego ya además que tampoco 00:51:30

es una línea es una operación tampoco gasta mucho hago que estos valores independientemente de que 00:51:38

salgan o no vuelvan y esto lo que hace es obligar a que vuelvan al más 90 o al menos 90 como valor 00:51:43

en máximo. Porque ya os digo, cuando se rota, a veces de la rotación se queda en el 90.05, ¿vale? Y sobrepasa un poco y a lo mejor ya hace que esto 00:51:48

sea condición de problemas. Con esto sí que decimos, si se pasa de los dos argumentos que tenemos aquí, de ese 90 o de ese menos 90, lo restringe 00:51:58

para que nunca sobrepase finalmente ese 90 y ese menos 90. Entonces, ahí aseguramos. Y ya, por último, lo que decimos es, ¿vale? Este valor de Euler-Engels 00:52:06

directamente lo modificamos, es decir, estamos como tocando el transform, estos valores que tenemos aquí, para que el X y el Y de esa rotación se mantengan estables, 00:52:17

no los estamos afectando, esto lo expliqué el otro día, que si ponemos el nombre del eje, pues se mantiene, no está habiendo ninguna perturbación de ella, 00:52:30

y coja este valor, que va a estar siempre entre máximo 90 o menos 90, y lo ponga en el Euler-Angels. 00:52:38

Entonces, básicamente estamos haciendo este rotate como veníamos haciendo, y con todo esto lo que hemos hecho es, por un lado, recoger el eje Z, 00:52:46

Hacer con esta operación 00:52:56

Que se mantenga entre el menos 180 00:52:58

Y el 180, porque lo que hace es 00:53:00

Dar unos valores 00:53:02

Que al darse entre 0 00:53:05

Y 360, se estabilizan 00:53:07

Restándole 180, ¿vale? 00:53:08

Y si es un 0, se queda en el menos 180 00:53:10

Y si al dar un máximo 00:53:12

De grados posibles 00:53:15

De 360, al resultado de esto 00:53:17

Antes de su operación 00:53:19

Antes de restarle 180 00:53:20

Si el máximo es 360 00:53:22

al restarle 180, se queda en 180, y si es 0, es decir, ha comenzado una rotación nueva, un ciclo de rotación, al restarle menos 180, se queda en el mínimo de 180. 00:53:24

Entonces, digamos que el rango de esos 360 grados, en vez de ir de 0 a 360, con esto hemos conseguido que se quede en un rango de menos 180 a 180, 00:53:35

que es lo que nos interesa para operar a nosotros con valores negativos, que es lo que nosotros vemos en ese transform. 00:53:45

Aquí fijamos esta rotación máxima o mínima, que es la que hemos establecido. Si quisiera que fuera menos 120 y 120, con esto, siempre y cuando esté dentro de este rango, podemos marcar una rotación máxima y mínima. 00:53:51

Y con esto, al final lo que decimos, esta rotación que hemos dado, al final que se traduzca y que se ponga en el transform, ¿vale? Dentro de este rango que se ha puesto aquí limitado por este clamp, ¿vale? Esta sería un poco la lógica. 00:54:12

Esto se puede hacer de más formas, evidentemente, hay muchas, pero bueno, esta es una que me sirve para explicar también esto del módulo y, ¿veis? Ahora el máximo es 120, a ver, 120, 120, espera, aquí hay algo que no me está gustando, que es, sí, está bien, está bien, es decir, debería funcionar correctamente. 00:54:26

solo que hay una cosa, esperad, que aquí voy a quitar 00:54:53

que igual lo está volviendo un poco 00:54:56

loquer, que es 00:54:58

vale 00:54:59

yo giro y se queda en 00:55:02

120, sobrepasa un poco los 90 00:55:03

y 120, vale 00:55:05

entonces ahora, es verdad que esta rotación es un poco 00:55:07

rara porque se queda como mirando para abajo, voy a poner 00:55:10

45, bueno, creo que se 00:55:12

entiende esto, ¿no? 00:55:14

45, 45 y con esto 00:55:16

ya tengo una rotación preparada para 00:55:17

tener límites, ¿vale? y en principio 00:55:20

más o menos debería funcionar en cualquier 45 menos 45 se queda ahí en un grado intermedio y 00:55:21

ahí sí que además ahí al ser un rotate sí que tiene ese suavizado independientemente de que 00:55:30

aquí tenga un input que tarde más o menos en captarse vale que ojo si vamos a hacer esta 00:55:37

yo le llamo interpolación a esta suavidad mejor dicho vale y queremos que sea todo en base al 00:55:43

código, aquí lo más correcto sería nuevamente poner un valor muy alto, ¿vale? 00:55:49

Porque no queremos que tarde en recoger el valor del input. 00:55:53

Queremos que vuelva a ser, como viene por defecto, por ejemplo, este 1000 y 1000, ¿vale? 00:55:56

Y, bueno, pues ahora la rotación empieza y se hace con el rotate, básicamente, ¿vale? 00:56:00

¿Vale? Entonces, bueno, ¿qué tal? A ver, voy a leer, que me escribís a veces. 00:56:08

Vale, no he escrito nada. ¿Qué tal esto? Entiendo que lo que es la instanciación, 00:56:14

Más o menos la entendéis con este detalle de que os puede interesar en muchas ocasiones que el elemento que estemos llevando o recogiendo en una variable de tipo GameObject no sea un prefab de la jerarquía, sino que normalmente nos va a interesar más que sea el prefab del proyecto en sí, ajeno a que se borre o no de una jerarquía uno de estos dos elementos. 00:56:18

De hecho, hay otro método del que se ha hablado un poco por encima, que es, y pensadlo, ahora mismo no tengo un ejemplo, me ha venido así de pronto, pero tened en cuenta que a lo mejor en un start instanciáis o recogéis un elemento que todavía no se ha creado la jerarquía. 00:56:48

Y todavía no está aquí. Y bueno, pues un poco dicho lo mismo, si yo la opción que dijera es este es el obstáculo que voy a instanciar, lo que estábamos hablando antes, lo voy a cambiar el nombre para que sea más notorio el cambio entre uno y otro, lo voy a llamar en español obstáculo. 00:57:04

Y el que estoy incorporando al instanciador es obstáculo, no obstáculo. Si yo este elemento a lo mejor lo genero en algún momento, que es en el start, y en ocasiones puede suceder que tengo aquí un, digamos que estoy incorporando un elemento a un serialize field, 00:57:21

En ocasiones, en vez de coger ese elemento, cargar ese GameObject, esa variable, en el momento de start, existe otro método que se ejecuta y está preparado antes de que se lance el script, que es este Awake. 00:57:44

Esto lo dejo ahí un poco planteado 00:57:57

Pero si en alguna ocasión os encontráis en la circunstancia 00:58:01

De que aquí queréis rellenar por código 00:58:05

Un gain object que todavía no se ha generado 00:58:08

En la jerarquía 00:58:11

En ocasiones se puede cargar previamente 00:58:14

Con este awake 00:58:17

Ahora mismo no me sale un ejemplo 00:58:18

Pero en algún momento de la vida puede suceder 00:58:20

Vale, me preguntan 00:58:24

Para que la rotación sea suave es mejor usar Euler Angle que Time Delta Time siempre. Vale, lo vuelvo a leer, ¿vale? Para que la rotación sea suave es mejor usar Euler Angle que Time Delta Time. 00:58:26

Se juntan dos cosas en esta consulta. Cuando se usa rotate y transform, en principio ya están estabilizados esos movimientos. No hace falta usar el time delta time. 00:58:46

Si buscamos, y ya hasta dudo a veces, pero vamos, en el Translate, perdón, en el Rotate, Transform, Translate, aquí lo tenemos, nos va a poner, la distancia es Translation, y, a ver, sí, bueno, no, qué diablos, sí que hay que poner el Time Delta Time. 00:59:04

Entonces lo que está diciendo el compañero, aquí básicamente estaría bien o sería adecuado, y luego subir el valor de rotación porque esto lo va a bajar, no sería ninguna tontería poner un time, delta time, para hacer esta estabilización que hablamos de la rotación, de los tiempos de ejecución de la date a lo largo del tiempo. 00:59:28

Entonces, una cosa es esta estabilización que se hace en el momento de la rotación con que luego estemos en todo momento recuperando un valor de los Euler angles, que es básicamente leer, en este caso cuando lo estamos recogiendo, leer lo que pone en el componente transform del objeto. 00:59:52

y si estás aplicando estos Euler angles, básicamente lo que estás haciendo es pasar una posición, una coordenada que ya tienes. 01:00:12

Por eso en este caso no habría que poner time delta time, porque ya está dando valores automáticamente. 01:00:25

Tendrás que estabilizar en todo caso lo que da ese valor para que llegue a los Euler angles. 01:00:33

No sé si me explico 01:00:39

Me pone, no, según entiendo es que los movimientos con físicas 01:00:42

No necesitas time delta time 01:00:45

Evidentemente, sí, es decir 01:00:46

Con físicas no, pero es que en este ejercicio 01:00:48

Ahora mismo no estamos usando 01:00:50

Ninguna física 01:00:52

Estamos cambiando el transform 01:00:53

De hecho en el tema 2 todavía no se ha explicado 01:00:55

Lo que son las físicas que se explican en el 3 01:00:58

Si aplicamos fuerza 01:00:59

Ahí va por otros 01:01:01

Por otros mecanismos 01:01:03

Que es que básicamente, entre otras cosas 01:01:05

No se debe usar el update 01:01:06

y por tanto no va a depender del tiempo de actualización del ordenador, sino que se va a usar el otro método que se habla, que es FixUpdate, que lo que hace es tener un tiempo de ejecución predeterminado, 01:01:08

que se va a ejecutar cada 0,02 segundos. Entonces ahí no hay que usar el TimeDeltaTime porque es constante ya de por sí. La ejecución, lo que hay aquí dentro, se va a hacer cada cierto tiempo. 01:01:23

No es como aquí, como comentamos el otro día en el update, que lo que va a hacer es, cuanto más rápido y cuanto más capacidad de procesamiento tenga el ordenador, más rápido va a ir ejecutando esos fotogramas de ejecución. Esto es muy adecuado para capturar, para recoger valores de interacción, para que sea cuanto antes mejor. 01:01:35

Pero una cosa son, y esto es importante y es esencial entenderlo, que es que cuando estamos usando un rotate, un translate, que vais a ver que además eso pertenece a la clase transform, son movimientos, lo que se llaman kinemáticos, kinéticos, lo he encontrado de las dos maneras. 01:01:55

Lo que estamos haciendo es como si aquí hiciéramos esto, mover y decirle por código, ah, vale, pues ve moviendo así o ve moviendo la rotación así, ¿vale? En cierto momento. En ese caso sí que lo hacemos en base a un update, ¿vale? Pero, y para compensarlo es cuando se usa el time delta time. 01:02:14

Cuando se usan físicas, que de hecho es de lo que va la tarea 3, pues ahí el time delta time no tendrá sentido porque ya está estable, ya es estable. 01:02:32

Entonces, vuelvo a la pregunta de antes, para que la rotación sea suave es mejor usar Euler angle que time delta time. 01:02:41

Es que no son contradictorias una de otras, son distintas cosas. 01:02:48

el huler ángel se refiere a estos valores de aquí de rotación vale y el tan delta time es un valor 01:02:51

porque en este uso al menos por el que se multiplican los valores de movimiento del 01:02:57

transform vale o vale para que sean más estables entonces no son las mismas cosas de todos modos 01:03:02

sí que ahora ahora me hace ha puesto que entiendo genial ahora me hace dudar en el transform en el 01:03:13

Vamos a ver un segundo los contenidos, que ahí ya me hace dudar, porque es verdad que si lo ponemos un rotate o un translate, mover y rotar objetos, métodos públicos de translate, transform translate, y es verdad que aquí ya está normalizado. 01:03:23

Es que no hay que hacerlo 01:03:50

Pero es verdad que leyendo ahora 01:03:52

Ah bueno 01:03:54

Es que me parece raro 01:03:57

Que cuando se 01:04:01

Realmente no sería necesario 01:04:03

Usar el time delta time 01:04:05

Porque es que estos valores 01:04:07

Ya están normalizados pero me extraña 01:04:09

Ahora que estoy intentando tenerlo claro 01:04:11

Me extraña 01:04:13

Aquí ponen time delta time básicamente 01:04:15

Porque lo que quieren 01:04:19

es que vaya sumándose 01:04:20

cada fotograma un valor 01:04:22

para que haya una rotación automática 01:04:24

aquí no es para estabilizar en este ejemplo 01:04:26

pero sí que es verdad que cuando usamos 01:04:27

aquí el translate en este caso sí que está haciendo 01:04:30

esta estabilización y como no pone nada 01:04:32

relativo a 01:04:34

a que esté 01:04:35

ya normalizado 01:04:38

pues 01:04:39

sí que no está de más poner 01:04:41

ese time delta time 01:04:44

no pone nada 01:04:46

Y viendo estos valores, además, sí que es conveniente usar el TimeDeltaTime, ¿vale? 01:04:49

Vale, dudas de esta tarea, porque si no paso a la 3, rápidamente, 01:04:59

bueno, rápidamente no, vaya, pequeña duda, ¿vale? 01:05:06

Pues, si es por... pequeña duda con la cámara, ¿vale? 01:05:10

Voy a ir modo cámara, dame un segundo. 01:05:14

voy a 01:05:17

bueno, de momento 01:05:19

te hablo por aquí mejor 01:05:20

dame un segundito que dejo esto aquí preparado 01:05:22

que si no luego de pronto hay fallos 01:05:24

ya os estaréis dando cuenta de lo pejiguero 01:05:26

que es esto del código 01:05:28

hay que tener mil ojos 01:05:30

porque los fallos pueden venir por tantos lados 01:05:32

dame un segundo y 01:05:35

vamos a la cámara 01:05:36

dime la consulta 01:05:37

yo la cosa es que estuve mirando porque 01:05:39

en teoría ya lo tengo hecho 01:05:42

me falta pulir los códigos 01:05:44

Y como tengo varios scripts distintos 01:05:46

Pues pulirlo 01:05:49

Entonces tengo dos códigos para la cámara 01:05:50

Porque estuve probando 01:05:52

Y el caso es que utilicé el Lucat 01:05:53

Para digamos una opción 01:05:55

Pero que pasa que cuando yo muevo la nave 01:05:59

Cuando muevo lo que es 01:06:01

El avión 01:06:03

La cámara digamos que está estática 01:06:04

Y lo que hace es, lo sigue 01:06:06

Pero si queda estática 01:06:08

Entonces lo que si, no se si estaría bien 01:06:09

Porque yo lo que hice fue 01:06:12

Espera que te digo, a ver porque le tengo por aquí el código 01:06:13

Sí, básicamente has puesto, claro, en LUCAT, tened en cuenta que lo que hace, a no ser que incorporeis más líneas de código para que se mueva, LUCAT lo que hace es meterle hacia dónde tiene que mirar. 01:06:16

Entonces lo que va a cambiar es la rotación relativa a dónde tiene que estar mirando, pero eso no significa que la cámara se mueva, solo rotará con respecto a su posición. 01:06:29

Se pueden combinar las dos cosas 01:06:39

Se puede combinar que se mueva 01:06:41

Y aparte que siempre esté mirando al objeto 01:06:42

Que en este caso es la nave 01:06:45

Yo lo que hice fue al final 01:06:46

Porque bueno, al final como estoy también con otras 01:06:48

Cosas aparte para ir aprendiendo un poco más de esto 01:06:51

Que imagino que está bien 01:06:53

Yo lo que tengo es que la cámara 01:06:55

Sigue la misma posición de donde está la nave 01:06:57

Pero la cámara 01:07:00

Le ha añadido otra coordenada 01:07:01

Para que esté un poco más detrás 01:07:03

Donde según se vaya moviendo la nave 01:07:04

No sé si estará correcto 01:07:07

Lo tendría que ver, pero sí, no suena mal. 01:07:08

Si queréis os enseño en este caso cómo lo tengo yo, para que también veáis. 01:07:13

Básicamente, para verlo, si os fijáis, la nave se mueve y la cámara tiene un cierto retardo. 01:07:18

Por eso da ese tirón cuando se para la nave, que sube o baja. 01:07:24

Mira, ya he cambiado algo por ahí, que no se están instanciando los obstáculos. 01:07:28

Pero eso, veis que tiene un cierto tirón. 01:07:33

Pero voy a poner el obstáculo porque es que sin obstáculo 01:07:35

Como que se pierde un poco la referencia 01:07:38

Y básicamente es lo mismo 01:07:40

Que voy a poner aquí obstáculo y me cargo este 01:07:42

Porque quiero que instancie 01:07:44

Los obstáculos, vale 01:07:46

Y creo que ya debería ir 01:07:47

Pues no, bueno, algo ha pasado por ahí, vale 01:07:49

Pero bueno, lo importante 01:07:51

Tienes que instanciar el prefab 01:07:53

Tienes que instanciar el prefab 01:07:55

Sí, sí, es el que tengo 01:07:58

Ah, vale, vale 01:08:00

Pero bueno, algo 01:08:02

he cambiado por ahí y luego 01:08:03

deje de explicar y hablar a la vez, es un jaleo 01:08:06

a ver, un segundo, si no 01:08:08

el obstáculo 01:08:10

la nave 01:08:14

pues sinceramente no sé 01:08:15

qué es, pero algo ha habido 01:08:18

por ahí 01:08:20

da igual, porque si de eso no hay 01:08:21

dudas, tampoco 01:08:24

no quiero instanciar 01:08:25

y esto es que antes, ah vale 01:08:31

sí, que he comentado sin querer en algún momento 01:08:33

vale, ya, lo estoy viendo en otro monitor que tengo 01:08:35

vale, explicar 01:08:38

algo he comentado, vale 01:08:40

ahí ya van saliendo cositas, vale 01:08:41

veis que eso, que cuando la cámara para 01:08:43

hasta, desde que para hasta que se coloca 01:08:45

la cámara hay un pequeño tirón, vale 01:08:47

es algo que se 01:08:49

pedía, ¿no? o que es 01:08:51

recomendable, entonces bueno, en esa 01:08:54

cámara, para que lo veáis, tengo 01:08:55

un script llamado camera follow 01:08:57

se puede llamar seguimiento cámara 01:08:59

vale, ya sabemos que eso es una convención 01:09:01

que usemos nosotros 01:09:04

Y vais a ver que lo que estoy buscando, las dos variables públicas o serializadas, que las tenemos aquí, básicamente tenemos por un lado, y son estas dos, una que tiene el objetivo al que tiene que estar siguiendo, que tenemos mejor dicho de referencia para que la cámara lo haga en relación a ese objeto. 01:09:05

básicamente lo que estamos haciendo 01:09:28

si lo decimos incluso verbalmente es 01:09:30

la cámara se va a mover 01:09:32

X en relación a 01:09:34

la nave, entonces siempre hay que tener 01:09:36

esa relación a la nave, aquí en vez de tener 01:09:39

el GameObject, lo que cojo son 01:09:41

que esto lo vimos también en la primera 01:09:43

tarea, os hablo de ello, la variable 01:09:45

transform para recoger 01:09:47

los valores de este componente 01:09:48

lo guarda y yo lo que le he 01:09:51

dicho a la nave es, oye, tú sigue a esta 01:09:53

nave prefab, es la referencia 01:09:55

Y vais a ver que lo que hago es, en el primer momento, según arranca el juego, es la posición actual, ¿vale? Esto que se llama current post, la posición actual en la que debería estar la nave, la cámara, perdonad, ¿vale? Este objeto que tiene el script, ¿vale? Que coja la posición de origen que tengo yo aquí, ¿vale? 01:09:57

¿Por qué? Porque si yo, y esto además, si no da tirones, si yo pongo aquí la cámara, vais a ver que cuando le doy al play, da ese tirón y se coloca, ¿vale? Esto da este efecto de que se va moviendo hacia ese punto, pero básicamente yo voy a estar en todo momento partiendo de una posición que marco y que deberíamos poner aquí como centrada para que coja esa de comienzo y luego en el update voy a estar diciendo, vale, creo una variable que está aquí, un vector 3, ¿vale? 01:10:20

Dado que hablamos ya de posiciones, rotaciones, escala, que se basan en tres valores, voy a crear un valor que se llama target post, que de momento simplemente guarda este vector, ¿vale? 01:10:48

Que va a coger la posición en los tres ejes de donde está la nave, ¿vale? Por eso pongo target y no es el transform, a diferencia de aquí, si os fijáis. 01:11:02

Pongo, coge la posición de esta nave en X 01:11:13

¿Vale? En X, básicamente, no quiero que haya un offset 01:11:16

No quiero que haya un offset lateral con respecto a la nave 01:11:19

Quiero que haya un offset hacia arriba, ¿vale? 01:11:23

Y en profundidad hacia atrás, ¿no? 01:11:25

Para que esté alejado hacia atrás y hacia arriba 01:11:27

Porque básicamente, pues es eso 01:11:30

Me quiero alejar hacia atrás y subirla un poco para angularlo hacia abajo 01:11:33

¿Qué hago? ¿Y qué se puede hacer? 01:11:36

Crear una variable, igual que se podría poner aquí un número a pelo 01:11:38

pero mejor si lo agrupamos en una variable, que uno indique cuánto va a ser ese offset en el eje Z y cuánto va a ser el offset en el eje Y. 01:11:40

Y le digo, el offset en el eje Y va a ser que va a coger la posición de la nave y si está en 10, se va a poner la cámara en 25, más arriba. 01:11:49

Y del Z, si la nave está en 0, se va a ir hacia atrás, va a ir hacia menos 6, porque es lo que he puesto aquí. 01:12:00

Con esto, al ir cambiando estos números, el offset va a ser mayor o menor. Aquí todavía no lo estamos aplicando. Lo tengo guardado y aquí me está dando la posición donde debería estar la cámara en relación al target, que es la nave. 01:12:07

Y luego le digo, ya sí, efectivamente. Ojo, quiero que la nave esté, se podría hacer directamente, se podría decir, oye, quiero que la nave esté en TargetPos. 01:12:22

Espera, voy a hacer otra cosa que si no veo que la lío 01:12:40

Que se me olvida 01:12:43

Voy a hacer que esto es buena práctica 01:12:44

Aquí tengo algo seguro que me funcionaba 01:12:46

Lo comento y ahora digo 01:12:48

Quiero que esté en target post 01:12:50

Target.post 01:12:51

No, no, yo quiero post 01:12:54

Target solamente 01:12:58

Eso también post 01:13:00

Vale, y quiero que en todo momento 01:13:00

La posición de este objeto 01:13:04

Cuando ponemos transform y posición 01:13:06

Nos hablamos de lo 01:13:08

La verdad es que a veces es redundante, pero es un poco para ir repitiendo y que vaya asentándose cosas. Quiero que la posición de este objeto sea la del target post, que es básicamente la que hemos guardado aquí con ya los offsets aplicados. 01:13:09

Si yo es esto lo que aplico a esta cámara 01:13:23

Pues vamos a ver que 01:13:26

No va a haber este retardo 01:13:28

Simplemente la cámara va a tener ese offset 01:13:29

Y se va a mover con la cámara 01:13:32

Como si estuviera anclada en este caso a la nave 01:13:34

A cierta distancia y se moviera con la nave 01:13:36

Vale, pues ya está 01:13:38

Si yo el offset le digo que en vez de 01:13:39

Z sea, ah bueno antes eso lo he dicho al revés 01:13:42

Que era Z y tal 01:13:44

Si le digo que en vez de a 15 unidades por detrás 01:13:45

Este a 50 01:13:48

Simplemente con cambiar ese valor 01:13:50

vais a ver que va a estar anclada igual 01:13:52

pero bastante más lejos 01:13:56

hasta aquí es eso, que haya 01:13:57

ese offset, lo voy a poner más cerca 01:14:01

que es lo que 01:14:03

sí, oigo por ahí un micro 01:14:05

te lleva una acotación 01:14:07

porque a mí me han preguntado también 01:14:10

algunos compañeros 01:14:11

y para aclarar un tema que cuando 01:14:12

aquí por ejemplo estamos hablando de 01:14:15

transform position 01:14:17

el transform se refiere al objeto 01:14:19

al que está asignado 01:14:21

este script 01:14:24

el transform o cualquier cosa que no le ponemos 01:14:25

antes en la clase 01:14:28

siempre estamos hablando del objeto al cual 01:14:29

está asociado, entonces es un punto 01:14:32

que a veces confunde a la gente 01:14:34

porque ahí tienes target, target, target 01:14:35

y vale, target sale 01:14:37

de arriba de la variable 01:14:39

pero realmente has puesto 01:14:41

transform position y 01:14:43

algunos, vale, pero transform de qué 01:14:45

de qué cosa 01:14:47

es importante creo que 01:14:47

aclarar ese punto si hay una confusión con eso esto ya se habló creo en otra 01:14:51

tutoría pero lo repetimos por supuesto ya hablamos que existe vale y esto en la 01:14:56

de instancia acción lo hablamos a colación de que también se creaba se 01:15:01

podía crear una variable de tipo transform y fijaos que aquí se refiere a 01:15:05

la clase transform con la t mayúscula vale normalmente y lo vais a ver en el 01:15:09

tema 3 cuando queremos hacer cambios en un componente es decir recordar que los 01:15:14

componentes son estos distintos bloques que proporcionan propiedades a 01:15:20

los GameObjects, hay uno que se llama transform que está siempre en 01:15:27

todos los GameObjects, a excepción de algunos de la UserInterface, bueno 01:15:32

algunos puntuales que no lo tienen, pero en general todos tienen este transform 01:15:37

porque todos se ubican en el espacio, tiene una rotación y una escala 01:15:40

impepinablemente. Entonces, a diferencia de por ejemplo lo que tendremos que hacer 01:15:43

En la siguiente tarea, cuando queramos cambiar, por ejemplo, estoy poniendo uno de los valores, una de las propiedades del componente RigidBody, que no se va a poder poner directamente RigidBody.más, ¿vale? Para cambiarlo. A diferencia de eso, en Transform se considera que al ser tan universal, ¿vale? Se puede apelar a él directamente sin tener que recogerlo, ¿vale? 01:15:47

Esto cuando veáis la unidad 2, vais a ver eso, que por ejemplo, si yo quiero cambiar, vamos a hacer el ejemplo de hecho, ¿vale? 01:16:13

Una de las propiedades de un RigidBody es la masa, ¿vale? El más. Y lo podemos querer cambiar. 01:16:19

Y yo digo, voy a crear un RigidBody, lo llamo RB, ahora os explico esto un poco más en detalle. 01:16:25

Aunque ya os digo que esto se explica en la unidad 3. 01:16:33

pero si yo capturo 01:16:36

este RigidBody 01:16:38

lo escribo y ahora lo voy explicando 01:16:40

que va a ser más sencillo 01:16:42

y yo, aquí me ha hecho lo que ha querido 01:16:44

digo, quiero meterme en la masa 01:16:46

y decirle que esto es igual a 10 01:16:48

¿vale? 01:16:51

básicamente con este código lo que estoy 01:16:53

diciéndole es 01:16:54

este objeto 01:16:55

que tiene este script 01:16:58

incluido, que es la 01:17:00

cámara, ¿vale? al final un script 01:17:02

se incorpora en un GameObject como un componente, si yo este componente, este objeto que tiene 01:17:04

esta clase CameraFollow, quiero cambiar sus valores, al final lo que tengo que hacer es 01:17:11

crear una clase que se llame como el componente. Y vais a ver que para ir accediendo a los 01:17:18

distintos componentes básicamente va a haber que hacer una variable de ese tipo 01:17:31

de componente por ejemplo si yo quiero variar los valores de cámara aquí habrá 01:17:35

una clase que se llama cámara si quiero variar los de pues yo que sé audio 01:17:42

listener va a haber una clase que se llama audio listener vale y está esta 01:17:46

creación de clases clase manipulador audio listener vale 01:17:53

Entonces tendremos que ir, para poder apelar a que estamos haciendo los cambios, va a haber siempre que crear una variable con el tipo de variable llamada como el componente. 01:18:00

A veces pueden cambiar un poco los nombres, pero fijáis que, no me lo sé de memoria, sé que como hay uno que se llama AudioListener, yo lo pongo ahí y es un tipo de clase posible, ¿vale? 01:18:11

Que se puede crear como variable. Y a partir de aquí lo usaremos con el nombre que hayamos atribuido a esa variable, ¿vale? 01:18:19

Entonces, ¿qué ocurre? Que hay un proceso intermedio, que es que aunque pongamos que aquí vamos a trabajar con una variable de tipo RigidBody, hasta que no le digamos a qué RigidBody se refiere, que es lo que se hace con esta operación, ahora la explicamos en más detalle, no va a poder hacer ningún cambio. 01:18:25

Fijaos, ¿vale? Bueno, primero, para que veáis que esto ocurre, si como yo le he dicho que la masa me la cambia a 10, yo cuando guardo y ejecuto este código, ¿vale? Vais a ver que efectivamente está cambiando la masa a 10. 01:18:47

veis que se ha puesto 10 al lanzarse 01:19:00

¿vale? que sí que está habiendo 01:19:03

este cambio mediante código 01:19:05

¿qué pasa si yo borro esta línea? 01:19:06

¿vale? 01:19:10

aparentemente no pasa nada 01:19:11

pero 01:19:12

vais a ver que solo por borrar esa línea 01:19:13

que ahora explicábamos, perdón 01:19:17

yo le doy a play y este cambio no se realiza 01:19:18

no se pone a 10 01:19:20

pero según la lógica 01:19:22

yo estoy diciendo que la variable 01:19:24

rb 01:19:27

se opere con 01:19:27

los contenidos de este componente RigidBody 01:19:30

y me cambie el parámetro, RB pues dentro tiene propiedades 01:19:33

que es el de masa, que me lo cambia a 10, ¿por qué no está haciendo esto? 01:19:38

porque hay que usar la captura de componentes 01:19:44

la captura de componentes básicamente es un paso, a veces un poco tedioso 01:19:46

que es igual que cuando decimos que esto es un transform y ponemos 01:19:50

un serialize field y hasta que no arrastramos en el inspector 01:19:54

cuál es ese elemento, no sabe a qué elemento tiene que influir 01:19:58

o cuál tiene que guardar aquí, voy a hacer el ejemplo de decir, 01:20:03

sería light fill y esto lo pongo como un serial light fill, 01:20:08

y tengo aquí ese serial light fill y como lo he generado como un serial light fill, 01:20:13

cuando yo voy a esta cámara, vais a ver que se ha generado un serial light fill 01:20:18

de esta variable llamada rb 01:20:24

que está pidiendo, ahora está vacío 01:20:26

está pidiendo que le incorporemos un RigidBody 01:20:28

¿qué quiere decir esto por defecto? 01:20:30

que hasta que no arrastremos 01:20:34

aquí un GameObject 01:20:35

con RigidBody 01:20:37

como por ejemplo este mismo, si yo arrastro 01:20:38

MainCamera, tiene un RigidBody 01:20:40

entonces me coge el RigidBody de MainCamera 01:20:42

y sabe que tiene que cambiar 01:20:44

rb tiene que cambiar este RigidBody 01:20:46

y no otro 01:20:48

pero hasta que no lo captura 01:20:49

o no se lo determinaba de una forma explícita 01:20:51

esto está vacío 01:20:54

simplemente ha creado una variable 01:20:55

que es de tipo RigidBody 01:20:57

y esto también lo comenté al principio 01:20:59

pero la gracia que tiene 01:21:02

que haya distintas clases 01:21:04

con los nombres de los componentes 01:21:06

es que aquí si nos metemos 01:21:08

ya os dije que si dais a la tecla control 01:21:09

sobre el nombre de 01:21:12

las variables 01:21:13

o mejor dicho, de las clases 01:21:15

lo que nos metemos es en un código 01:21:17

que ya alguien ha hecho en Unity 01:21:19

o no sé quién desarrolla esto, sinceramente 01:21:21

con todo lo que se ocupa ese componente, ¿vale? 01:21:24

Por eso ya aparecen estas variables, estos campos serializados, 01:21:29

por eso básicamente un componente tiene unas propiedades y no otras, ¿vale? 01:21:33

Y unos comportamientos y no otros, ¿vale? 01:21:37

Entonces, recordad que básicamente tenemos preparado que queremos afectar a un componente 01:21:39

y por eso ponemos su nombre, pero hasta que no le digamos qué componente de los que hay en la escena es, 01:21:45

básicamente Unity no sabe con cuál tiene que hacer nada. 01:21:50

a ver 01:21:54

ahí estamos, otra vez 01:21:56

¿vale? entonces 01:21:59

¿cómo se hace esto? se puede hacer 01:22:00

o mediante un serialize fill y decírselo 01:22:03

a través del editor, que es lo que hemos hecho 01:22:05

con este target, ¿vale? 01:22:07

o podemos hacerlo por código 01:22:09

ya os digo, es que esto estamos yendo un paso más adelante 01:22:10

porque de esto, porque es la primera vez que es necesario 01:22:12

realmente, es en la unidad 3 01:22:14

¿vale? pero bueno, como estamos ya en el paso 01:22:17

de dar el salto a la unidad 3 01:22:19

lo que hay que hacer es, una vez se ha creado esta caja 01:22:20

Recordad, esta variable, que a partir de ahora, aunque sea de tipo RigidBody, su nombre que le hemos puesto es RB, como podríamos poner Joaquín, yo que sé, cualquiera, ¿vale? Yo puedo decirle, vale, RB, esta variable, esta caja, lo que tiene que usar es coger este componente, ¿vale? Y la sintaxis es la que sigue. 01:22:23

Se abren estas llavecitas y paréntesis. El paréntesis aquí, por defecto, en los usos que le vamos a dar nosotros, sirve, y recordad que cuando estamos llamando, esto lo hacíamos, por ejemplo, en el que hemos visto antes de mover el objeto, 01:22:42

para que se sepa que un método al que estamos llamando es un método y no otra cosa, hay que poner esos paréntesis. 01:23:04

Si no, no es un método. Siempre que veáis unos paréntesis llenos o vacíos después de un nombre, 01:23:11

suele ser porque es un método al que estamos apelando. Entonces, GetComponent es un método, 01:23:17

pero funciona de una forma diferente a otras ocasiones, que es que en estas llaves es donde ponemos el nombre del componente. 01:23:22

¿Vale? Con esta 01:23:28

línea lo que estamos haciendo es 01:23:30

que esta caja que abrimos aquí de tipo 01:23:32

RigidBody, porque vamos a usar las propiedades 01:23:34

que se han ya 01:23:36

programado previamente 01:23:38

de ese componente llamado RigidBody 01:23:39

es decirle, vale, yo quiero 01:23:42

que guardes en esa caja 01:23:44

el componente RigidBody de este objeto 01:23:46

que tiene el script 01:23:48

es decir, ahora mismo en RB 01:23:49

como este es el script que tiene 01:23:51

este código, ¿vale? 01:23:54

al lanzarse en el start dice, vale, me 01:23:56

meto y le digo, a ver, bueno, esto ya lo puedo cerrar, me meto y dice, a ver, me meto y cojo el componente que hay en este objeto, porque no le estoy 01:23:58

diciendo que sea en otro, RigidBody, ¿vale? Y lo meto, me ha dicho en, este ya también me lo voy a mover, y me ha dicho que lo meta en RB, ¿vale? 01:24:08

Y a partir de ahora RB sí que se va a estar refiriendo en todo caso a ese componente que está en este objeto, ¿vale? Y por eso, a partir de ahí, sí 01:24:19

podemos entrar en las propiedades. Yo ahora pongo rb y al dar a punto y ver las propiedades vais a ver que hay muchas propiedades, pero básicamente 01:24:27

eskinematic, quedad con estos nombres, eskinematic, más, si voy arriba estará drag, por ejemplo, angular drag, drag, ¿vale? 01:24:37

Todo esto son propiedades que si os fijáis lo que hacen es alterar el contenido de este componente, ¿vale? Es la forma de acceder. 01:24:46

Si yo aquí pongo drag y le digo que drag es igual a 10, nuevamente, cuando guardo, estoy diciendo, vale, capturo en una variable de tipo RigidBody, mediante esta operación, este RigidBody, ya puedo acceder directamente a las propiedades de este RigidBody, entre una de ellas es drag. 01:24:53

Al darle a reproducir, vais a ver que drag se pone a 10. Esta es la forma de acceder por código a las propiedades de cada componente. 01:25:14

¿Vale? Vuelvo rápidamente y luego volvemos a esto. ¿Qué sucede con el transform? Que si esto hubiera que hacerlo con el transform para cambiar la posición, ¿vale? Para acceder a position, sería un rollo, por decirlo así rápido. 01:25:23

Habría que hacer transform, darle el target o el nombre que fuera, luego target, luego igual a getComponent, transform, ¿vale? Y esto sería para preparar que target funcionara como transform y ya pudiera entrar a position o a lo que fuera. 01:25:37

¿Qué han hecho? Se ha simplificado porque Transform se usa tanto que sin necesidad de hacer nada de todo esto que hemos hecho para, por ejemplo, RB o acceder a cualquier otro, ¿vale? Y esto es cualquier otro de los componentes en los que queramos cambiar parámetros o propiedades, ¿vale? 01:25:54

Pues directamente al dar a transform ya se ha hecho toda esa operación. Es un atajo, digamos, a este componente transform, ¿vale? Lo veis, transform es la clase donde está todo el código, pero hay un atajo que es con este transform ya que apela directamente a todo este recorrido que hemos hecho. 01:26:10

Y por eso ya podemos acceder al position, al Euler angles, a la escala local, ¿vale? Por eso es esa diferencia entre el transform o otros tipos de componentes, ¿vale? 01:26:25

¿Qué pasa? Que cuando damos al transform, básicamente en una línea estamos diciendo que está refiriéndose al transform de ese objeto, no de otro, de ese objeto. 01:26:41

Por eso, a diferencia de cuando usamos el transform capturado por un serialize fill llamado target, aquí al decirle target.position, no estamos accediendo a las propiedades del transform de ese objeto, estamos accediendo a las propiedades de transform de ese objeto al que hemos referenciado aquí. 01:26:49

Y por eso ese target.position no se refiere a la posición del mismo objeto que tiene el script, sino a la posición, ahí está accediendo al transform de este objeto, aquí. 01:27:06

¿Hasta aquí qué tal? 01:27:24

A ver, también se puede plantear que por defecto un script ha hecho una captura de transform, pero que no necesitaba... 01:27:27

Sí, es lo que acabo de explicar, que no hay que especificar en el caso de transform del mismo objeto que está apelando a su transform, ¿vale? 01:27:33

Componer transform, ya estamos hablando de su propio componente transform. 01:27:41

Vale, y bueno, sí, es justo lo que has puesto, ¿vale? 01:27:45

Entonces, lo llevo un poco más, ¿vale? Por si esto os ayuda. 01:27:48

Sé que es un poco lío, pero básicamente es quedarse con que para cambiar valores de un componente, 01:27:53

Que básicamente lo vamos a hacer constantemente, porque esto también lo expliqué, pero creo que no es de más. Cuando creamos un objeto vacío, ves que ya viene con el transform, ¿vale? Otra pista de que el transform es tan universal que ya se hacen atajos para acceder a él, pero que al final lo que proporciona que un objeto sea de una forma u otra es los diferentes componentes que vamos incorporando, esos bloques de código que ya están prehechos con sus configuraciones, comportamientos, etc. 01:27:58

Entonces básicamente todo lo que vamos a ir haciendo es ir cambiando los distintos componentes de cada objeto. Si queremos cambiar los valores de un componente, como acabamos de decir, habrá que hacer ese tipo de variable con el nombre del componente y guardarlo en una variable. 01:28:27

Y ojo, porque también os he dicho que los scripts, a su modo, también son componentes. Ya os he dicho. Esto al final, aunque es una script, se llama CameraFollow y es un componente. Lo hemos incorporado como cualquier otro componente. Por eso hay que arrastrar al GameObject, porque hay que incorporarlo como componente. 01:28:46

A estos scripts se puede hacer desde otros scripts también poniendo su nombre. Si yo pongo aquí Camera Follow, ¿vale? Veis que esto no existía por defecto. Esto se llama así porque hay un componente que he creado yo, en este caso, que se llama Camera Follow. 01:29:02

Y por eso sale aquí. Si yo desde otro código, ¿vale? Y este ya os digo que es el que tiene el código, pero si yo me meto en otro de los scripts que estoy usando, a ver, aquí tengo scripts, pues yo que sé, el de instanciar, ¿vale? Lo pongo aquí, yo que sé. 01:29:19

Y yo quisiera cambiar algo de ese otro script que he creado yo, ¿vale? Yo si me meto y busco Camera Follow, veis que está aquí. En parte porque cuando, esto lo hace automáticamente Unity, pero cuando generamos esta clase, que es en el fondo el componente, veréis que es pública por defecto. 01:29:35

Entonces, al ser pública, podemos acceder de otros códigos. Si recordáis, el ámbito es público, es general, se puede acceder de otros puntos. Por eso, si yo ahora quiero acceder a Camera Follow y le digo, vale, este se va a llamar CF, ¿qué problema hay? 01:29:54

que yo si luego en el start digo 01:30:09

camera follow 01:30:12

follow 01:30:13

y he puesto 01:30:15

bueno, habría que hacer 01:30:18

alguna variable 01:30:20

pero, a ver 01:30:23

dejadme que me meta 01:30:24

espera, que ya no sé dónde tengo cada código 01:30:26

aquí, vale, lo voy a unir al otro 01:30:28

para tenerlo ahí pegaico 01:30:30

aquí el problema que voy a tener en un rato 01:30:31

es que he desorganizado tanto 01:30:34

todo que me voy a volver loco, pero vale 01:30:36

Yo tengo, igual que tengo propiedades, a lo mejor yo quiero acceder al Offset Camera Z de Camera Follow, que es una de sus propiedades. Si doy aquí a Offset Camera, no sale aquí en primer punto porque no es público. 01:30:38

Para que sea público hay que ponerlo aquí y hay que ponerlo como público, si no se encapsula. Si yo ahora pongo punto, ¿aparecerá offset cámara? No. ¿Por qué? 01:30:57

Porque nuevamente nos falta una operación que es decir cuál es este cameraFollow. En principio habrá que decirle que cf capture el cameraFollow con el problema de que si ponemos esto así va a buscar dentro de sus componentes ese cameraFollow. 01:31:13

Y Camera Follow no está dentro de los componentes del objeto, del GameObject que tiene instanciar obstáculos. Es decir, yo voy al Instanciador que es el que tiene instanciar obstáculos y no tiene ningún componente llamado Camera Follow. 01:31:37

está en 01:31:54

main camera, ¿vale? 01:31:55

es un poco lo mismo de antes 01:31:58

¿qué hay que hacer? pues hay dos formas 01:32:00

o hacer que esto sea 01:32:02

un serialize field 01:32:04

y le decimos, arrastrando en el editor 01:32:05

esto lo voy a comentar porque si no igual da fallo 01:32:10

arrastrar cuál es 01:32:12

el game object que sí tiene ese camera follow 01:32:14

y ya sí que al poner cf podremos 01:32:16

acceder a sus variables 01:32:18

¿vale? y 01:32:20

primero tenemos que ir 01:32:22

instanciador, a ver, tengo que guardar primero 01:32:23

Si ahora vamos a instanciador, guardo, a ver si me hace caso, ahora instanciador, bueno, tiene el de obstáculo y el de camera follow, porque no está saliendo, debería salir, bla, bla, bla, vale, aquí, ah, hay algo que no está bien, 35, 18, y en el script, camera follow, vale, que es que he dejado algo por ahí también a medias. 01:32:26

ser cámara solo y aquí a vale si hay un error y esto puede que esté dando problemas vale guardo 01:33:03

a ver si ahora sí vale ahí está vale y ahora en el distanciador veis que está esperando que le 01:33:10

diga vale pero este cámara follow de dónde sale porque ojo el camera follow es un script que 01:33:18

hemos incorporado a main camera pero podemos haber arrastrado más objetos también tiene esa lógica de 01:33:23

determinar a qué objeto y qué main camera es el que cambiamos. Si ahora vamos a instanciador le 01:33:27

decimos vale el camera follow del que hablamos es este, el de main camera. Hemos arrastrado main 01:33:34

camera y él ya sabe que tiene que buscar el script porque es de tipo camera follow que realmente es 01:33:39

de tipo script. Por eso sale ese iconito de script y no el de prefab por ejemplo. ¿Ahora qué ocurre? 01:33:44

Cuando vamos a este código, al código en el que hemos llamado a Camera Follow, que lo tengo aquí, ahora sí que cuando yo, sin hacer que componen, porque se lo hemos pasado de forma explícita por el editor, cuando damos a CF, al dar punto, sí que aparecerán Offset Camera, Offset Camera Z, Smooth Time, 01:33:52

que son las variables o propiedades que sí hemos creado en esta clase, en este script. 01:34:16

¿Esto qué significa? Que de una forma ya que nos permite cambiar casi cualquier valor de un componente, 01:34:26

si en el start, lo voy a poner en el update, yo qué sé, por ponerlo ahí, bueno, no me ha hecho caso. 01:34:33

Update, update, update, espera. 01:34:41

No es ese el update que quiero. Bueno, sí, sí, sí, es el void update, pero debería, bueno, pensaba que salía igualmente, ¿vale? Aquí tenemos el update, ¿vale? El ciclo. Aquí nos pone private, no nos da igual. 01:34:46

si yo ahora le digo, vale, quiero 01:34:59

yo ahora todo lo que ponga cf 01:35:02

me estoy refiriendo a ese 01:35:04

a ese componente camera follow 01:35:05

al otro script, básicamente, a lo que tengo 01:35:10

aquí, vale, y le voy a decir que por ejemplo 01:35:12

el camera offset 01:35:14

en z, vale 01:35:16

en vez de ponerlo en su código, voy a decirle 01:35:18

es 50 01:35:20

y ahora que va a pasar, que cuando empezamos en el juego 01:35:21

cuando llegue a este punto 01:35:24

le estamos diciendo por un código que 01:35:26

cambie otro de nuestros códigos ni siquiera es uno de los componentes que ya viene por unity sino 01:35:28

uno de nuestros códigos y aunque aquí hubiéramos puesto el offset de z 15 vais a ver que se va a 01:35:32

poner en 50 es decir que igual que hemos hablado antes tú tú tú se va a poner a 50 de distancia la 01:35:38

cámara lo ponemos aquí y vais a fijaros bueno que está alejado a ver 50 50 porque no me está 01:35:46

cogiendo el offset 01:35:54

y ha puesto aquí unas cuantas cosas 01:35:55

ah vale, espera, si le doy a este 01:36:03

offset vais a ver que aquí 01:36:05

el camera offset de pronto se ha puesto en 01:36:07

50 y no está en el objeto instanciador 01:36:09

que es en el que tenemos ese script, sino 01:36:11

en el de main camera y aquí se ha puesto 01:36:13

el 50 01:36:15

¿vale? 01:36:16

otra forma y ya la última 01:36:19

a ver, os leo que no sé si me estáis 01:36:21

¿me vais siguiendo más o menos? 01:36:23

esto es también practicarlo y tener 01:36:26

la lógica de que lo que hemos hecho por SerializeField es una forma rápida 01:36:27

y por el editor y visual de indicar qué componente o incluso el GameObject 01:36:31

de la jerarquía es al que queremos afectar con esa variable. 01:36:39

Pero esto llegará a un punto que si no lo queremos hacer por el editor 01:36:42

y lo queremos hacer por código, tenemos que usar esto del GetComponent 01:36:46

y tener la lógica de, ojo, que no por declarar una variable de un tipo 01:36:49

o que se llame igual que un componente, vamos ya a poder afectar ese componente, 01:36:54

sino que hay que capturarlo primero e indicarle qué componente en concreto es al que vamos a afectar. 01:36:58

Esto ya os digo, en el tema 3 es más capital. 01:37:05

Y bueno, todo esto me sirve también para explicar por qué el transform tiene ese atajo del transform con minúscula, 01:37:08

sin tener que capturar nada, si hablamos del transform del mismo objeto de sí mismo. 01:37:14

Si hablamos de otro, pues habrá que indicar qué otro objeto es. 01:37:19

Y esto que hemos hecho aquí, con un serialize fill, hablar de otro camera follow, si en vez de hacerlo con un serialize fill lo queremos hacer por código, el problema que tenemos aquí es que decimos lo que hemos dicho antes. 01:37:24

He preparado que recoja este script de cameraFollow, pero en un objeto que no tiene cameraFollow. Entonces, al hacer la captura de componente, esta línea es incorrecta, porque aquí le estamos diciendo en el script, en este script, en el objeto, mejor dicho, que tiene este script, que es instanciar obstáculos y es instanciador, busca o captura el componente llamado cameraFollow y aquí no está. 01:37:40

Por tanto, esto va a dar error, es decir, no va a ser, de hecho, si intento darle a play, vais a ver que lo que ocurre es que da un error, porque dice, no encuentro la referencia al objeto que me estás pidiendo que capture, porque aquí no hay nada que se llame camera follow. 01:38:05

vale, en ese caso 01:38:21

ya esto es por complicarse, a lo mejor lo más rápido 01:38:23

aquí, nuestro nivel es poner un serial 01:38:25

y fill, arrastrar y se lo decimos 01:38:27

pero aquí lo que podemos hacer es decirle 01:38:29

hay distintos 01:38:31

mira, de hecho, si nos metemos 01:38:34

esto ya de momento es más avanzado 01:38:36

y hay uno de los vídeos de Álvaro Holguera 01:38:38

que si no me equivoco está en la unidad 3 01:38:39

que habla de esto específicamente 01:38:41

pero hay distintos, si nos ponemos 01:38:43

en la API de 01:38:45

Unity Documentation y damos a 01:38:47

GetComponent, vais a ver que hay GetComponent a pelo, que es este que estamos usando, 01:38:49

este de cógeme el componente llamado tal y me lo guardas en una variable de este tipo. 01:38:55

De hecho, veis que suele haber esta rima de que el tipo de variable luego es la que se busca aquí, 01:39:00

se llaman igual. 01:39:04

Aquí lo ha hecho en una sola línea, pero es exactamente lo mismo que hemos hecho, 01:39:06

la lógica que hemos usado en los ejemplos. 01:39:10

Pero si vais viendo, hay otros que se llaman GetComponentInChildren, 01:39:12

GetComponentImparent 01:39:16

GetComponentIndex 01:39:18

GetComponent, por ejemplo, vamos a usar uno que se llama 01:39:20

GetComponentImparent 01:39:23

Ya, bueno 01:39:31

Podríamos usar 01:39:34

Bueno, esto sirve sobre todo para buscar los componentes 01:39:38

En los hijos de la jerarquía o en los padres 01:39:40

¿Vale? 01:39:43

Pero ahora mismo no me viene 01:39:43

Pero hay otro 01:39:46

Eso es, eso es. Vale, perdonad, que es que a veces yo me desubico. Hay otro tipo de métodos, como este define, si lo buscamos aquí, que es buscar un objeto por distintas tipologías o distintas criterios que demos. 01:39:48

Podemos buscarlo por el tipo de objeto que sea 01:40:11

Por el nombre 01:40:13

Por el index que tenga 01:40:14

Por ejemplo, si vemos este transform 01:40:17

Find 01:40:19

No, mejor dicho, GameObjectFind 01:40:20

Lo que hace será buscar un GameObject 01:40:23

En la jerarquía 01:40:25

Pero por código, ojo 01:40:27

Entonces con esto lo que podemos hacer es poner 01:40:29

Poniendo esta operación 01:40:31

De GameObject.find 01:40:33

Y poniéndole un nombre 01:40:35

Vamos a decirle, oye, búscame 01:40:37

dentro de la jerarquía un objeto que se llame 01:40:39

de tal manera y de ese objeto 01:40:42

ya dentro me buscas el componente 01:40:44

que se llame CameraFollow, ¿vale? 01:40:45

Por ejemplo, nos vamos a quedar que aquí hay un 01:40:47

GameObject que se llama MainCamera que es el que tiene el 01:40:49

CameraFollow. Entonces vamos ahí 01:40:51

y le decimos 01:40:53

¿vale? Quiero que me hagas... 01:40:55

Bueno, borro esto de... Bueno, el GameComponent lo dejo ahí. 01:40:57

Es dentro 01:41:00

de la clase GameObject 01:41:01

que es una genérica que guarda 01:41:03

un montón de código relacionado con 01:41:05

la gestión de los game objects 01:41:07

vale 01:41:10

le decimos find 01:41:11

y vamos a decirle que en vez de por 01:41:13

se puede buscar por las etiquetas que ya lo veremos 01:41:15

por los tipos, hay muchos tipos de búsqueda 01:41:17

pero el básico 01:41:20

si le damos aquí entre el paréntesis 01:41:21

el nombre de lo que tiene que buscar 01:41:24

que es main camera hemos dicho 01:41:25

al ser un string hay que meterlo tal cual 01:41:27

lo que va a hacer es 01:41:29

en este punto de código va a buscar 01:41:31

un objeto de la jerarquía llamado main camera 01:41:33

Es decir, llegará aquí al primero que encuentre, se llama así. Si hay varios llamados de distinta forma, solo cogería el primero en este caso. Y ya una vez encontrado, seguimos enlazando, quiero que de ese objeto que has llegado hasta ahí, me cojas el componente llamado Camera Follow. 01:41:36

Y ahí sí que está cogiendo el componente de otro objeto. En vez de hacerlo por un serialize field arrastrando, aquí estamos diciendo busca este objeto y me coges el componente. Por eso ahora, aunque estemos haciéndolo a través, sin serialize field, del instanciador, de este script que tenemos en instanciador, vais a ver que va a cambiar el valor del offset de cámara Z a 50, porque estamos apelando a otro objeto y a otro código. 01:41:52

Entonces yo ahora si ejecuto el juego vais a ver que aquí se ponen 50. Desde el script de un GameObject estamos buscando el componente en otro GameObject y cambiamos una de sus propiedades. Esto es como la base para interconectar distintos scripts. 01:42:21

vale, indica un compañero que se 01:42:39

marcha 01:42:43

si la subiremos cuando se acabe 01:42:44

la tutoría, ¿qué tal hasta aquí? 01:42:47

¿me seguís? todo esto lo he contado, no es lo que tenía 01:42:49

pensado contaros, lo porque 01:42:51

ya hubo un día que os introduje un poco esto 01:42:52

y hay uno de los vídeos de Álvaro Dolguera 01:42:55

que habla también de esto, entonces 01:42:57

bueno, pero creo que 01:42:58

sirve para que lo vayáis 01:43:00

entendiendo, ¿vale? 01:43:02

sobre todo es entender la lógica, luego ya 01:43:04

pues igual que ahora no me acordaba de que era fine 01:43:06

Eso es, buscas en internet 01:43:08

¿Cómo se buscaba un GameObject? Por código 01:43:09

Y ya rápidamente alguien os va a decir 01:43:11

Pues con el método, fine 01:43:14

Y ya os metéis en fine y veis como funciona 01:43:15

¿Vale? Esto dicho rápido 01:43:17

Sé que es más complicado que esto 01:43:20

Pero que bueno, que es un poco la lógica que creo que hay que seguir 01:43:21

Para resolver dudas 01:43:24

Vale 01:43:26

Pues 01:43:27

Con esto 01:43:28

No he hecho la introducción 01:43:31

A la tarea 3 01:43:33

Pero os dejo que la leáis 01:43:35

Y en un par de semanas o así hacemos otra tutoría y hablamos más de ella. ¿Dudas con algo de lo que hemos tratado hoy? ¿Algo que queráis que veamos de la UT2? Que es el momento porque es en la que estamos, es el mejor momento. Vale, pues entiendo que no. 01:43:37

¿Alguien ha empezado la tarea 3? 01:43:59

Por ver si hay alguna duda así de 01:44:04

De comienzo 01:44:06

¿No? 01:44:08

Vale, pues sí, entonces casi 01:44:14

Esperamos a que 01:44:16

Leáis y veáis que se pide 01:44:17

Y ya nos pegamos con ella, ¿vale? 01:44:20

Y las dudas que tengáis 01:44:22

Las dudas que tengáis me las 01:44:23

Las vais planteando, ¿de acuerdo? 01:44:25

Vale 01:44:31

¿Dudas? 01:44:31

ya os digo, todo esto que os he contado 01:44:34

ahora me la planteas 01:44:40

es para explicar esto del transform con minúscula 01:44:42

que me habéis dicho, la forma rápida 01:44:44

pero también desorganizada 01:44:46

porque hay que estar arrastrando y cuando se 01:44:47

resetean ciertos objetos puede dar 01:44:50

error o que se desconfiguren 01:44:52

cosas y hay que estar pendiente de volver a arrastrar 01:44:54

la forma rápida de acceder 01:44:56

a los componentes es arrastrando con este serialize 01:44:58

fill, por eso 01:45:00

es una de las primeras cosas 01:45:01

que se ven, claro, por código 01:45:04

porque es la forma de poder 01:45:05

referirnos a objetos y cambiar propiedad 01:45:08

de objetos 01:45:09

vale, sí, esa duda que creo que 01:45:10

me está escribiendo alguien, la esperamos 01:45:14

sí, hola, mejor lo 01:45:16

digo por micro 01:45:18

no sé si es por 01:45:19

mi internet o por la retransmisión 01:45:22

pero los 01:45:23

cuando lanzabas 01:45:25

la escena 01:45:27

y salían los objetos 01:45:30

o sea, los obstáculos, iban como 01:45:31

a tirones. ¿Eso es por mi internet o es porque 01:45:34

realmente van como un poco a 01:45:36

tirones? A ver, déjame que lo veamos. 01:45:38

Pues 01:45:41

probablemente es de tu internet, sí. 01:45:41

Sí puede ser, ¿eh? A ver, yo también lo veo 01:45:44

así, pero es por la transmisión que está 01:45:46

haciendo en OBS. 01:45:47

Vale, vale, vale. 01:45:49

A 30 frames o menos incluso. 01:45:51

Sí, o bueno, o que el 01:45:53

refresco de la retransmisión 01:45:54

pues está, no va todo lo fluida que debiera. 01:45:57

Sí, sí, es algo que veis vosotros, no es... 01:46:00

Después cuando veas el 01:46:02

vídeo que suba, se va a ver mejor 01:46:03

en mejor calidad. Vale, vale, porque 01:46:05

cuando me meta yo a poner 01:46:07

el código, digo, a lo mejor le meto un 01:46:09

parejo un poco enfermizo, pero 01:46:11

un time delta time para que vaya un poco más 01:46:13

fluido el obstáculo. 01:46:15

De todos modos, yo 01:46:17

te doy un consejo con respecto a esto 01:46:19

del time delta time, y es 01:46:21

que cuando tengas claro que hay que usarlo, lo uses, 01:46:22

pero si no lo usas 01:46:26

y no ves que te... Es decir, 01:46:27

si de verdad lo necesitas, lo vas a notar. 01:46:29

Y en ese caso, buscas 01:46:31

qué movimiento, qué propiedad es la que hay que meterle 01:46:32

time delta time, teniendo en cuenta que luego 01:46:35

vas a tener que multiplicar por un valor 01:46:37

alto para compensar 01:46:39

con una fuerza de un speed para compensar 01:46:41

que los valores se van a ver reducidos 01:46:42

pero te quiero decir que 01:46:44

que bueno, que el time delta time 01:46:47

está para calibrar o para 01:46:49

equilibrar 01:46:51

estos movimientos 01:46:52

pero que se puede añadir siempre a posteriori 01:46:54

sabes que a veces a uno le puede paralizar 01:46:56

mucho el meto el time delta time o no 01:46:59

pues cuando veas que lo necesitas lo metes después pero bueno en todo caso no te va a solucionar el 01:47:01

problema que se vea para nación y que al revés normalmente tú vas a ver si no lo aplicas vas 01:47:07

a ver que va todo muy rápido no exactamente así que sí que puede dar tirones es decir lo que lo 01:47:12

expliqué en otra tutoría lo que hace es compensar el update en la velocidad de ejecución de fotograma 01:47:22

lo ejecuta, si tienes un ordenador muy variable 01:47:27

o que va dando como saltos o inestables 01:47:30

sí que se pueden dar tirones 01:47:32

y el time delta time sí que te lo equilibra 01:47:33

sí tiene una influencia en eso 01:47:35

pero el efecto también 01:47:37

colateral es que al aplicar 01:47:40

un time delta time en una multiplicación de un movimiento 01:47:42

va a haber que compensar 01:47:44

subiendo otro 01:47:46

de los elementos que multiplique 01:47:48

porque es verdad que te va a reducir la velocidad 01:47:50

pero la función primaria 01:47:51

por la que la estamos usando nosotros 01:47:53

porque tiene más funciones, como hacer un contador, etcétera, que va acumulando tiempo, etcétera, bueno, es para calibrar las velocidades, ¿vale? 01:47:55

Y también para que los valores, pues eso, sean constantes. Eso lo dije en otra tutoría y creo que puse ejemplos más o menos claros. 01:48:04

Pero bueno, lo dicho, si ves que hay cosas ilógicas o que das alto, lo pones. Pero por defecto, es verdad, y lleva razón, que cuando se usan movimientos cinemáticos, 01:48:12

el time delta time es 01:48:21

recomendable ponerlo, cuando hacemos físicas 01:48:23

y esto lo pone el tema, no porque 01:48:26

normalmente también, normalmente 01:48:28

siempre tiene sus vueltas 01:48:30

vamos a usarlo dentro del 01:48:32

fix update 01:48:34

bueno, cuando leáis el tema se explica 01:48:35

esto un poco 01:48:38

vale, perfecto, gracias 01:48:38

ok 01:48:42

bueno, alguna 01:48:43