Tutoría 4 - DEIM - UT2 - Curso 23·24 -11 Enero

Como entiendo por lo que me habéis estado contando en la iniciación, digamos, que hemos 00:00:00

estado hablando un poquillo sobre cómo estáis afrontando el módulo, me habéis indicado 00:00:07

que no habéis... que habéis leído el tema 2, ya lo habéis ojeado, pero la tarea no 00:00:12

la habéis comenzado. Si la pensáis presentar, vaya, ya sabéis que son voluntarias. Hay 00:00:20

un compañero que me ha dejado en el foro una consulta, ¿vale?, porque... lo ha dejado 00:00:26

en el foro. Por cierto, os recomiendo que uséis el foro para consultas de las tareas, 00:00:32

casi todos podemos participar. Vale, y me ha dejado un poco su solución del movimiento 00:00:35

de la nave que hay que conseguir en esta tarea. Pero le daba un fallo, más que un fallo, 00:00:40

es, bueno, que no estaba haciendo el comportamiento correspondiente al que buscaba, porque estaba 00:00:48

mezclando tanto el desplazamiento, sobre todo el horizontal, con la rotación. Y eso 00:00:54

en principio no tiene problema, porque si revisáis un poco el código, si os fijáis, 00:01:00

el axis lo está captando en este momento, dentro de su update. Esto lo podéis luego 00:01:07

consultar en el foro, también con más detalle. Y esa variable que ha creado con un float 00:01:14

que va del menos uno al uno, según se introduce en este axis, lo usa tanto a la vez para el 00:01:21

translate como para el rotate. Entonces eso significa que si ha configurado que este axis 00:01:28

se controle con, por poner un ejemplo, las teclas A y D, cuando se mueva a la derecha, 00:01:34

con este translate, también rotará a la derecha, que es lo que está configurado aquí. 00:01:40

El problema que hay ahora mismo es que hay que entender que tanto el translate como el rotate 00:01:46

tienen una propiedad muy interesante y que hay que saber, porque si no da problemas como este. 00:01:51

El problema que se está encontrando, ahora que he introducido esto, que se está encontrando el 00:01:57

compañero, y un segundo, que el código lo he repicado y lo he introducido en esta nave, es que cuando yo 00:02:01

empiezo a controlar la nave, subo o bajo sin problema, ha hecho bien la interacción, 00:02:09

pero cuando se da a un lateral, lo que hace es que la nave empieza a orbitar con respecto a un 00:02:17

centro que tiene ahí. No es que vaya a la izquierda y gire y vire a la izquierda también mientras se 00:02:22

desplaza a la izquierda. Y parece que es que se está moviendo a la derecha desde un punto 00:02:28

concreto. Aunque parezca eso, lo que está ocurriendo es que, para ver cómo deducir 00:02:33

estas cosas o buscar más información, si buscamos la documentación de, por ejemplo, 00:02:42

el rotate, que en el translate ocurre un poco lo mismo, de la API, el transform rotate, 00:02:50

aquí estaría. No estoy buscando el manual, sino que estoy buscando la API. 00:02:57

¿Estás compartiendo pantalla? 00:03:03

No. 00:03:07

Ah, vale, vale. 00:03:08

Sí, sí, es esencial, porque si no, no sé cómo me podéis seguir. 00:03:09

Vale, gracias por decírmelo. Ahora sí que, vale. 00:03:18

No sabía si lo estabas compartiendo. 00:03:23

No, no, no. Perdona, que no lo había hecho. Vale. Nada, eso. Ahí en el foro de DeinUT2, 00:03:26

un código que el compañero ha indicado con el problema de que si ejecuto el movimiento lateral, 00:03:33

también rota, pero le ocurre este problema que estábamos viendo, que es que ahora mismo, 00:03:41

cuando vamos a derecha-izquierda, no está yendo a la derecha y a la A y B rotas, 00:03:47

sino que parece que está orbitando con respecto a un punto. Y la interpretación que puede ser es 00:03:51

que estemos yendo a izquierda-derecha con respecto a este punto central, por ejemplo, 00:03:56

si os dais cuenta, parece que está haciendo aquí un giro en base a este punto que podría ser un nulo. 00:03:59

Pero lo que está ocurriendo en realidad, es que en su código, 00:04:04

un segundete, que lo tengo en el foro, aquí está, está cogiendo el axis, la interacción del eje, 00:04:11

vale, en un punto, en esta variable se está guardando, y luego lo emplea tanto en el 00:04:22

Translate como en el Rotate. Si os fijáis, en ambos casos está el desplazamiento. ¿Y qué 00:04:28

está ocurriendo? Y es en donde me había quedado, que si vamos al API, a ver, vamos al API, 00:04:33

a cómo, a qué, digamos, aquí lo tenemos, aquí está. Cuando estamos usando Transform, 00:04:40

Rotate, como en este caso, estamos incorporando un vector 3 correspondiente a la rotación y a los 00:04:54

tres ejes que hay en la rotación del Transform, pero el problema es que hay un segundo parámetro 00:05:03

que no es obligatorio poner, que es el Relativo a, ¿no? Con respecto a qué hace el giro, con 00:05:09

respecto a qué hace la traslación de posición, ¿vale? Y por defecto, aquí pone Relativo a, 00:05:15

y hay dos opciones, Relativo a sí mismo o Relativo al mundo. Esto lo podríais, por ejemplo, 00:05:21

explicar aquí, ¿vale? Y si veis por defecto, tiene un igual y un valor ya asignado, ¿vale? Recordad 00:05:26

que cuando tenemos un método, pues va teniendo distintas sobrecargas, esto lo hemos visto en 00:05:33

otras tutorías, en los que en cada uno, pues en el orden que se va estableciendo, separados por coma, 00:05:38

se van incorporando valores. En el caso del Rotate, por ejemplo, o si buscamos el Transform, vais a 00:05:43

ver que está ese segundo argumento, ¿vale? Relativo a, con respecto a qué espacio lo hace. Voy a ponerlo 00:05:52

en el Transform, que de hecho creo que se va a ver mejor. Si vamos a Transform, Translate, vais a ver 00:06:01

que la declaración es igual. Va a tener el vector 3 de hacia dónde vamos a decir que se vaya moviendo 00:06:08

esa GameObject, que lo tenga incorporado, pero luego hay un segundo valor, ¿vale? Que por 00:06:14

defecto ya tiene un valor. Y si os fijáis, vienen dos formas de declarar este método. Una, solo meter 00:06:22

el vector y ya está. Y otra que es meter el vector y este segundo espacio. ¿Qué pasa? Que si no ponemos 00:06:28

nada explícitamente como segundo argumento, si lo declaramos así, el método ya está interpretando 00:06:36

que usa a sí mismo para realizar este movimiento. ¿Y qué está ocurriendo? ¿Vale? Vamos a ver el 00:06:44

ejemplo. Si volvemos a desarrollar el juego, a ponerlo en marcha, lo que está sucediendo es que 00:06:49

estamos moviendo la nave a la derecha, por ejemplo, ¿vale? Y a la vez está rotando rotando hacia la 00:06:58

derecha. Entonces, ¿qué ocurre? No es que la nave esté orbitando en base a un punto intermedio, sino que 00:07:04

como va rotando hacia la derecha, y con respecto a la rotación que tiene sí mismo, este self, ¿no? 00:07:10

que significa mismo, ¿vale? Va identificando esta rotación y lo mueve a la derecha y sigue rotando 00:07:15

a la derecha y se realimentan los dos movimientos. Es decir, la nave está tanto yendo a la 00:07:21

derecha como rotando, pero con respecto a la rotación que va teniendo en cada momento. Ahí 00:07:27

está el problema que, por ejemplo, tenía el compañero, que si no definimos nada explícitamente, como 00:07:32

sucedía en su... Si no pone nada explícitamente relacionado con el espacio, por defecto, 00:07:39

va a coger el valor que tenga ya sí mismo. Es decir, si hay una rotación, por poner algo de 45 00:07:51

grados hacia la derecha, pues la nave se moverá en diagonal, ¿no? Porque básicamente está cogiendo 00:07:57

la rotación que tenga en cada momento y ya respecto a esa, mueve la nave hacia la derecha también. 00:08:03

Entonces, se están realimentando. ¿Cómo se solucionaría esto para que hiciera el comportamiento 00:08:08

esperado? Si habéis visto el vídeo, por ejemplo, de la tarea de ejemplo, más o menos se interpreta 00:08:13

que se busca, que es que la nave, dando a cruceta, vaya derecha-izquierda, arriba-abajo y luego, si 00:08:20

queremos, independientemente con otros controles, podamos rotar la izquierda-derecha, ¿vale? Pues 00:08:27

para, por ejemplo, pasar entre estos obstáculos que se van generando. Entonces, ahora 00:08:32

mismo el problema que hay es que, como están las dos acciones, tanto la de rotar como la de 00:08:37

como la de moverse, conectadas a una misma entrada, no hay opción de que cuando yo pulse la derecha 00:08:43

sólo haga la rotación o el movimiento, ¿no? Lo que sí se puede hacer, por ejemplo, como primer paso, y aquí 00:08:51

tengo, es el mismo código que ha puesto Francisco Javier, lo tengo incorporado, ¿vale? Aquí en el 00:08:57

código es exactamente lo mismo, aquí se ve un poco más claro. Es decir que, independientemente de la 00:09:04

rotación que tenga, ¿vale? Los movimientos en vertical, en horizontal, perdonad, es decir, de izquierda- 00:09:09

derecha de la nave, lo hagan en relación al espacio, pero no el sí mismo, no el que tiene ya por defecto, 00:09:15

sino en relación al mundo, ¿vale? A las coordenadas del mundo, que esas son imperturbables. Entiendo, si ya 00:09:22

habéis estado manejando en otros módulos software de 3D, igual que aquí hay ya una forma de 00:09:28

indicar que algo son variables locales o globales, y vais a ver que si yo, por ejemplo, cojo de prueba 00:09:36

y roto este objeto, ¿vale? Si yo lo pongo como local y como global, veis que aquí varían las 00:09:43

coordenadas. ¿Por qué? Porque global siempre va a enseñar las coordenadas en relación al gizmo del 00:09:50

mundo, que es imperturbable, siempre va a haber, digamos, una brújula de hacia dónde apuntan las 00:09:55

cosas, y nosotros podemos, cada objeto que relacionemos, que se vaya representando en base a 00:10:00

esas coordenadas, pero también podemos ver el objeto como local, y como este objeto está rotado en 00:10:05

47 grados, ¿vale? Pues tiene esta inclinación, y por tanto, el eje Y, que es el que representa la 00:10:11

verticalidad, aquí está rotado también. Esto está relacionado con cómo funciona aquí el movimiento, ¿no? 00:10:18

Si aquí ponemos que el movimiento lo haga independientemente de la rotación que tenga y que 00:10:25

en lo que se fije sea en las coordenadas del mundo, va a dar igual que la nave esté rotada o no, porque lo 00:10:31

que va a hacer es moverse hacia ese lado, aunque luego, independientemente, esté rotando. Voy a 00:10:37

deshacer esto un segundo, ¿vale? Para no tener una rotación por defecto, y voy a guardar este script para 00:10:45

que veáis que con este cambio simple, aunque seguimos teniendo un solo input horizontal y 00:10:52

tanto va a desplazarse hacia los lados como que va a rotar, va a hacerse con el mismo control, ¿vale? 00:10:58

Pero vais a ver que ya tiene un comportamiento más esperado, es decir, seguirá rotando porque no hemos 00:11:05

puesto límites a esta rotación, ¿vale? Eso es algo que también está pasando, pero veis que ya no está 00:11:10

orbitando aparentemente, sino que va derecha-izquierda y aparte rota también, ¿vale? Esto es la razón por 00:11:15

la que le sucedía eso al compañero. Si alguien creo que ha pedido... 00:11:21

Sí, yo había pedido una palabra más. Mira, una duda que tengo. ¿Se podría hacer, como lo tengo en la parte de arriba, con los cursores arriba, abajo, izquierda, derecha, y con una booleana, un condicional, para que si, por ejemplo, le doy a la izquierda o a la derecha, además de girar con respecto al mundo en izquierda, se rote un poquito, en determinados grados, con una condicional? 00:11:24

Sí, claro. De hecho... 00:11:48

Perdona, es que lo he intentado con un condicional, con un if, si gira, o un if-else, y no había manera de sacarlo, no he conseguido hacerlo. 00:11:51

Lo que quieres hacer es limitar, ¿no?, la rotación. 00:12:00

Claro, eso es decir, yo le giro el avión a la izquierda y además, cada vez que le doy a la izquierda, es que se rote un poquito. 00:12:04

Y limitando, a lo mejor, a 30 grados, por ejemplo. Se rota 30 grados, además de girarle a la izquierda, y se rota 30 grados a la derecha, además de girarle a la derecha, con una booleana o con un if o algo así. 00:12:10

Era la pregunta. 00:12:21

Eres Francisco Javier, vale, que te has incorporado, que estaba justo hablando de tu tarea. 00:12:21

Vale, ¿has visto esta primera parte de la solución? 00:12:25

Sí, sí, he visto. 00:12:28

Ahora, lo que hay que pensar, ¿vale?, es que aquí, en ningún momento, que por eso estás diciendo lo de la condicional, en ningún momento estás rotando, estás diciendo, llega hasta 90 grados, o no estás diciendo en ningún momento, sino que esto se va sumando, sumando, sumando, y por eso gira indefinidamente, ¿no? 00:12:30

¿Sí? Hasta aquí lo tenemos claro, ¿vale? 00:12:45

Entonces, tú ten en cuenta que cuando estás cogiendo un axis, como en este caso, ¿vale?, el horizontal, lo que se está trasladando es un valor de entre menos uno o uno, ¿no?, el negativo y el positivo. 00:12:49

Esto, bueno, lo explica en el contenido, y si tenéis alguna duda, lo vemos. 00:13:02

Vamos, de hecho, si yo voy y muestro los valores que tiene el Desk X en cada momento, sabemos que esto está al final del UI, ¿vale?, y esto, cuando yo de a derecha a izquierda, si voy a la consola, vais a ver que el desplazamiento X pasa a 10 o a menos 10, ¿vale? 00:13:09

En realidad es uno menos uno, lo que pasa es que si te fijas, como tú has puesto aquí que se multiplica por una velocidad que has definido, ¿vale?, en el editor, aquí lo tengo, y que lo has puesto de 10 en ambos casos, por eso se multiplica por 10, ¿no? 00:13:35

Cosa importante también, recomiendo, no tiene por qué serlo, pero recomiendo que si vais a multiplicar o hacer alguna operación en los inputs, lo hagáis posteriormente a la recogida del input, ¿vale? 00:13:50

Por ejemplo, aquí este Speed, en vez de ponerlo aquí, ¿vale?, lo pondría aquí también, como multiplicador de la traslación, y como multiplicador en este caso de la rotación, y también el vertical, que habías hecho un poco la misma operación, lo multipliques aquí, ¿por qué? 00:14:04

Porque si no, a lo mejor este input horizontal lo estás usando para varias cosas, y si ya por defecto le has dicho que esté multiplicado por 10 en este caso, pues siempre va a estar por 10, en la operación que queremos que a lo mejor tenga esta velocidad, que se puede llamar Speed o Movimiento-Velocidad, y luego aquí podemos tener Velocidad-Rotación, y podemos hacer dos variables distintas, ¿vale? Por eso os recomiendo que lo hagas así. 00:14:24

Una vez dicho esto, aquí hay que poner algún límite. Bueno, y lo primero, ahora si vuelvo con este Debug Log a mostrar la velocidad que está cogiendo, vais a ver que va de 1 a menos 1. Bueno, no se está refrescando porque se ha perdonado que no lo está cogiendo bien, pero ahora sí, ¿vale? De 1 a menos 1. Doy a la izquierda menos 1 y doy a la derecha y es 1, ¿vale? 00:14:47

Entonces, lo que tenemos que interpretar es jugar a nuestro favor con ese tipo de datos, ¿vale? Ahora mismo en la rotación, ¿no? Vamos a meternos en eso, que ojo, lo mismo, podríamos hacer otro input distinto con otras teclas designadas en el Input Manager, ahora si tenéis dudas de esto, lo definimos también, lo vemos, pero podríamos hacer controles independientes de que cuando dé a la izquierda-derecha vaya a la izquierda-derecha con las crucetas y luego haya dos teclas, la Q y la Y, ¿vale? 00:15:13

Y la E para la rotación solo, ¿vale? Aquí no pasa eso porque están las dos vinculadas a este axis horizontal, ¿vale? 00:15:43

¿Cómo definimos, o una forma de hacerlo, cómo definimos hasta dónde tiene que llegar este Rotate, para marcar unos límites? En algún momento habrá que decirle cuál es el máximo al que puede llegar la nave, ¿no? 00:15:51

Entonces, si por ejemplo dijéramos, si, igual que has hecho aquí, ¿vale? Que has puesto condicionales de si la posición en Y es menor a esto, pues oye, que no pase de ahí y todo el rato esté refrescando a menos 10, ¿no? 00:16:10

Hemos puesto un límite. Aquí habría que hacer un poco lo mismo con si, y aquí hay algo un poco a veces complejo que es saber cómo usamos la rotación, porque ya lo pone en el temario, que realmente la rotación internamente, todos los cálculos lo está haciendo en cuatro dimensiones, en cuatro ejes, ¿vale? En cuaterniones, ¿vale? 00:16:25

Pero, si nos fijamos en nuestra comprensión, en qué haréis todo el rato en dos over 3D y cómo manipulamos aquí en el editor de Unity, la rotación está basada en tres ejes, como todo el transform, ¿no? 00:16:43

Cuando queramos aludir a estos tres ejes, siempre hay que decir, en vez de rotation, que sería lo lógico, como hacemos en position, ¿vale? El problema es que esto está con un cuaternion. 00:16:56

Lo que hay que hacer es decirle que estamos trabajando en lo que se llaman los Euler angles, que es lo mismo, ¿vale? Poner transform.EulerAngles es lo mismo que aludir a estos tres ejes, al vector 3 de estos tres ejes, ¿no? 00:17:10

Entonces, si le decimos, al rotar a derecha e izquierda, básicamente lo que estamos haciendo es rotar en, a ver, porque yo siempre me confundo, pero es en Z, ¿no? En un vector 3, ¿vale? Sería en Z. 00:17:22

Igual que has hecho aquí, ¿vale? Puedes decir, si el Euler angle, el Z, es, voy a ponerme a Yorkie de 45, ¿vale? Ahora seguimos diciéndole, podemos decir, cuando esto llega a 45, pues ojo, que no vas a poder avanzar un poco lo que acabas de hacer ahí, ¿vale? 00:17:32

Entonces, ¿qué problema hay entre esta? Es decir, ¿por qué no podemos hacer lo mismo con respecto a esto? Pues porque aquí estás usando el rotate, que lo que hace es que va sumando, progresivamente, ¿vale? Más grados a la posición que ya tenga, a la rotación que ya tenga, ¿no? 00:17:53

Si aquí decimos que, si el... Espera, perdona, que me estoy cayendo del cable. Un segundo, eh, perdona. Que no, que me estoy cayendo de la silla. Espera. A ver. Ahora, perdona, eh, que me estaba liando con el cable y me estaba estrangulando a mí mismo. Vale, perdona. 00:18:14

¿Me oís, verdad, que he tirado el cable? 00:18:37

Sí. Vale. Sí, vale. Si decimos que, si se da esta condición que es menos de 45, ¿vale? Se podría decir, pues la condición, lo que ocurre es, vale, abro llaves. 00:18:41

Lo pongo así, bien formateado, para que lo veamos todos mejor. Si la posición en algún momento es, perdona, mayor que 45, es decir, que va a la derecha. Bueno, esto es a la izquierda, perdona, que es que los ejes van al revés, ¿vale? 00:18:56

Si supera los 45 o los 90, ¿vale? Imaginaos lo que queráis de límite. Si es mayor que 45, habrá que hacer que esto también tenga un... Es decir, no, perdona, es que se puede hacer de las dos formas. 00:19:10

Si esto supera los 45, ¿vale? Este transform rotate no va a funcionar, porque no se está dando la condición, ¿vale? Entonces, ahora mismo vamos a ver qué ocurre. Si yo activo el juego, a ver, he guardado, creo que sí, ¿vale? 00:19:29

Si yo empiezo a moverme a la derecha... Vale, perdonad, lo que hay que hacer es que sea menor de 45. Si es menor de 45, como cuando comienza, que es 0, 0, 0, ¿vale? Guardo. Ahora sí, eso os explico más formas de hacer esto. 00:19:44

Pero si es menor de 45, ¿debería funcionar? No está funcionando, pero no sé si es que he cambiado alguna cosa por el camino. Si es mayor, dale, que no quiero mayor, que quiero menor. 00:20:04

Que no me sale. Ah, ahora sí. Ahora sí debería ir. Si el euro del ángel es mayor, no quiere hacerlo. Vale. Sí, vale, estamos aquí. Vector3, bla, bla, bla. Desplazamiento X. 00:20:21

Si transforme en Z es menor que 45, vale, transforme en Rotate. Vector2, rotación. A ver si es que he cambiado la rotación, perdonad. Está por 10, ¿vale? 00:20:42

Y por Speed, que también está a 10. Si yo dejo esto, lo corto y lo pego. Para comprobar que algo está funcionando lo borro y debería. 00:20:58

Vale, ahora sí lo está haciendo. Si el Transform Angle es menor de 45, debería hacerlo. Ahora digo cómo lo enfocaría yo, pero en teoría debería estar funcionando. 00:21:29

Ahora sí que lo coge el muchacho. ¿Por qué no lo guardo? Estoy en el tuyo, en tu prefab, en todo. Vale. 00:21:48

En este caso, la forma que yo lo hubiera planteado es que, a ver, ¿por qué no está cogiendo? Si el Transform Angle es menor que 45, sí, pero si es que lo está cogiendo bien. 00:22:10

Y es menor de 45, sí, pero debería. Vale, lo voy a... 00:22:27

Vale, pues por lo que sea no lo está haciendo correctamente. Sí, sí, debería estar haciéndolo bien. 00:22:40

Lo pruebo rápido, no voy a hacer que os cuente aquí algo que luego tampoco es. 00:22:59

Vale, las rotaciones siempre suelen dar problemas cuando mezclamos. 00:23:14

Es que debería estar funcionando. A ver, una última. Esperamos que si esto funciona, no tiene mucho sentido. 00:23:29

Y aparte no está haciendo la condición, por tanto, no, porque esto está basado en un quaterniones y por eso no tiene sentido. 00:23:55

Vale, la opción que os daría para este caso, aunque esto debería funcionar, pero está viendo algo que evidentemente no está funcionando. 00:24:02

Estoy en los Shifts, Transform Angle, si el Z, a ver si es que va a ser... No, no, pero es que claro, el Z es el que nos interesa. 00:24:11

Si es menor que 45, sí, sí, es menor que 45, Transform Rotate. 00:24:21

Perdón, ya lo dejo de intentar y os digo cómo lo podemos resolver. Pero es que no está haciendo lo que yo quiero, hombre. 00:24:31

Pues no sé por qué no lo hace. Debería ser menor. Vale, dicho esto, aunque no os estoy dando la solución en base a cómo tú lo estabas planteando, 00:24:44

hay otra forma de conseguir esto, que es, en vez de decir que la nave esté sumando en todo momento rotación, 00:24:55

porque en realidad, como tenemos unos límites tan establecidos, no queremos que siga sumando rotación, 00:25:11

lo que podemos hacer es aludir directamente a los grados que tiene. Me explico. Comento esta línea. 00:25:15

Si yo le digo que lo que tiene que hacer es que la interacción que nosotros hagamos, en este caso con esta variable, 00:25:24

que se vea directamente reflejado en los grados de rotación, que os he dicho, de tres dimensiones, no el quaternion, 00:25:33

lo que podemos decirle es que genere un vector 3, que al final alude a las tres dimensiones que tenemos aquí, 00:25:42

como habréis visto ya en el Transform y en el Translate, y que la rotación, en este caso, que solo nos interesa, 00:25:53

como estábamos intentando hacer en el eje Z, en realidad forcemos a que nunca se mueva la rotación en los ejes que no nos interesan, X e Y, 00:26:01

que también se podría hacer, me da miedo hacerlo, pero también se podría decir que mantenga, como has hecho tú aquí, 00:26:11

que mantenga la rotación que ya tenía en X, que sería lo mismo que cero en este caso, porque no nos interesa que rote en otro eje que no sea Z, 00:26:18

por el videojuego que estamos haciendo. Pero si le decimos que mantenga los valores que ya tuviera en Z en Y, 00:26:29

y lo que hacemos es decirle, ojo, lo que metamos por desplazamiento, por esta variable de X, que se multiplique por el límite que queramos, 00:26:38

lo pongo como float, ¿y esto qué significa? Que si está la nave, estamos dando a la derecha, esto valdrá 1, que se multiplicará por 90, 00:26:50

y si le damos a la izquierda valdrá menos 1, que valdrá menos 90. ¿Con esto qué conseguimos? 00:27:05

Que ahora hay que invertirlo, porque lo está haciendo al revés, pero que cuando yo dé a la derecha, se gira hacia un lado, 00:27:17

y cuando gira a la izquierda, gira hasta el límite de ese lado. Y aquí ocurren varias cosas, que también es a lo que quiero llegar con esto. 00:27:25

Lo primero, habría que decirle que estos valores están invertidos, porque si os fijáis en lo que hemos dicho antes, 00:27:32

que cuando rotamos y sumamos, debería ir a la derecha, va a la izquierda, entonces invertir una variable simplemente se puede hacer 00:27:41

poniéndolo menos delante de la variable, y la hace negativa, lo cual invierte. O por el 90, los máximos grados que tenga, 00:27:49

y ahora sí que lo va a hacer en la dirección que nos interese. Entonces, ahora sí que voy a la derecha, roto a la izquierda, 00:27:59

a la derecha y a la izquierda. ¿Qué problema hay? Si lo pensamos un poco, que era lo que podíamos conseguir con el Rotate, 00:28:07

porque se va sumando progresivamente en el tiempo, y con la Speed, con la velocidad, podíamos decir qué velocidad tiene el giro o no. 00:28:15

Pero si nos damos cuenta ahora mismo, en ningún momento, a diferencia de lo que hemos hecho aquí, y aquí también sería recomendable 00:28:23

poner un Time Delta Time, por lo que explica en el tema, que lo que hace es regular la velocidad de procesamiento del ordenador 00:28:31

para que independientemente del ordenador en el que trabajemos sea constante, lo que vamos a conseguir aquí, 00:28:40

el problema que vamos a tener ahora con esto, es que el 90 que hemos metido, que es un valor exacto, se vea reducido, 00:28:48

ya no sea ese ángulo máximo, porque va a multiplicar el 90 por 0, algo, y vais a ver que ahora casi no tiene rotación. 00:28:57

Sería recomendable hacer esto, pero como voy a explicar ahora, es que lo que está ocurriendo y lo que hace que haya un momento 00:29:07

de interpolación entre que damos al botón y vaya, a ver, que creo que no he guardado, exacto, entre el momento que demos a la interpolación 00:29:13

y ocurra o no ocurra, es que cuando damos a Play, si os fijáis, hay un momento que entre que yo pulso la tecla derecha ahora 00:29:21

y hace el giro completo esos 90, pues durará ponerle un segundo. ¿Y dónde está ese segundo aquí ahora mismo? 00:29:30

En ningún lado, es decir, le estamos dando un input que va de 0 a 1 o de 0 a menos 1, no sabemos en cuánto tiempo, 00:29:39

y llega hasta este límite porque lo está multiplicando. ¿Qué ocurre? Que lo que se explica también en el tema es que los axis, 00:29:46

como es este caso, se configuran, tienen un panel de configuración en el Input Manager. Si dais a Editar y a Project Settings, 00:29:54

hay una sección que se llama Input Manager donde podemos ir configurando estas entradas de los axis. 00:30:05

Y, por ejemplo, en Horizontal, definir qué se corresponde con el valor negativo de ese eje que va de menos 1 a 1. 00:30:14

Y aquí, por ejemplo, yo podría hacer este control tanto con la cruceta, con esta izquierda derecha de la cruceta, 00:30:21

como con el negativo de la A, que va a la izquierda, como a la D, que es lo que estoy usando. 00:30:28

Y, si os fijáis, incluso ya aparece por defecto otro horizontal que, como no tiene ninguna tecla asignada, no está funcionando. 00:30:33

Pero ahí podríamos asignar cualquier otro tipo de valor, por ejemplo, los botones de un mando. 00:30:45

Para eso habría que poner aquí, en negativo y positivo, los códigos que aparecen en el tema, asociados a los mandos, por ejemplo. 00:30:51

Esto simplemente para que sepáis cómo habría que configurarlo si usáramos estas herramientas. 00:30:59

Pero en el tema, en contenido, si vais a la sección de los inputs, aquí interactividad, aquí aparece, por ejemplo, 00:31:09

en el mando de la Xbox, por distintos valores que se asocian, habría que poner JoystickButton0. 00:31:22

Si aquí ponemos JoystickButton0, cuando tiramos a esta tecla correspondiente a la A, que es esta A, 00:31:28

en este mando, cada mando tiene unos, pues haría esa acción, igual que estamos haciendo ahora con el teclado. 00:31:35

Habría que mapearlo en relación al mando que tengamos. 00:31:41

Dicho esto, también aquí hay tres valores que se pueden definir también cómo funcionan. 00:31:46

Esta gravedad, esta muerte, este death, que es el que menos nos interesa, y la sensitivity. 00:31:54

Esto aparece en el tema esbozado, pero aquí puede ser útil, porque lo que hace es que la sensibilidad, 00:31:59

la sensibilidad, ¿vale? Significa que desde que damos a un botón hasta que llega a su valor máximo, ¿vale? 00:32:05

Esto no es un joystick de la Xbox o de la Play, que tiene valores intermedios. 00:32:13

Cuando pulsamos una tecla, por ejemplo, a la cruceta derecha, es 0 o 1 cuando pulsamos. 00:32:18

Lo que pasa es que si os dais cuenta, cuando yo doy al Play y le doy a esa cruceta, 00:32:24

a ver si lo hace, hay como un periodo que pasa por valores intermedios, ¿vale? 00:32:29

Y que de hecho está relacionado con esos momentos en los que la multiplicación que tenemos aquí en el código 00:32:34

no llega a ser el límite de 90 o menos 90. 00:32:40

Entonces, digamos que con estos valores podemos definir la velocidad a la que se hacen estas interpolaciones, 00:32:44

en movimiento horizontal, en este caso. 00:32:51

Pues, por ejemplo, la sensibilidad es el tiempo que tarda desde que damos a un control hasta que llega a ese control. 00:32:53

Si yo pusiera 0, incluso aunque esté en Play podemos probarlo, vais a ver... 00:33:01

¿Por qué no lo haces? Igual hay que poner un 1, perdón. 00:33:09

¿Vale? Veis que ahora el movimiento es bastante más lento. 00:33:12

El movimiento de inicio, ¿vale? Porque, a ver, si yo le pongo 001, más exagerado, 00:33:15

vais a ver que lo está haciendo a una velocidad ínfima. 00:33:22

A ver, 0,5. Ahora lo hace mucho más despacio, pero cuando suelto vuelve rápido, ¿vale? 00:33:27

Porque hay otro valor que es el de la gravedad. 00:33:33

Es decir, cuando nos dejamos de intervenir con un input, ¿cuánto tarda en volver? 00:33:35

¿Vale? Entonces, con estos valores podemos decir la velocidad que tiene el giro de la nave 00:33:40

y cuánto tarda en volver a su valor. 00:33:45

¿Vale? Es una forma de resolver esto, que lo que hace es usar el axis para... 00:33:48

para ese valor de 1-1 multiplicarlo por un valor que nos sirve para poner unos límites. 00:33:57

¿Vale? Eso sería una de las formas. 00:34:04

Otra de las formas es usar, a lo mejor, el smooth damp, etc., ¿vale? 00:34:06

Para hacer que la rotación sea suave. 00:34:13

Porque, básicamente, aquí lo que estamos haciendo es cambiar la coordenada según pulsamos. 00:34:16

Así que, ¿verdad? Como tenemos esta interpolación de tiempo, vamos, este tiempo que hay en medio, 00:34:21

por esta sensibilidad que hemos definido aquí en el Input Manager, 00:34:27

pues el ir de un número a otro tiene un desfase. 00:34:31

Pero, realmente, si nos ponemos puros, lo que estamos haciendo es intervenir en la rotación del transform. 00:34:35

Por tanto, cuando estamos introduciendo inputs, está ese offset, ese tiempo, 00:34:41

pero en otros valores puede ser algo repentino. 00:34:48

Entonces, en esos casos, se podría recurrir a lo que pone el tema del smooth damp al final del tema, 00:34:51

que sirve para ir suavizando los movimientos entre un valor y otro. 00:34:56

Evidentemente, aquí también lo que podríamos hacer es hacer un Rotate Data, ¿vale? 00:35:02

Que sea un float que recoja un input, un gain axis, que sea diferente al de horizontal. 00:35:12

Y que se llame como queramos nosotros. 00:35:21

Ahora vemos cómo se ve reflejado esto. 00:35:25

Que sea rotando, ¿vale? 00:35:27

Entonces, ahora mismo podemos crear otro input, que básicamente nosotros llamamos como queramos 00:35:31

y podamos poner las teclas que queramos para que coja un axis del menos uno a uno, 00:35:41

que es lo que hacen los axis. 00:35:45

Entonces, si aquí, por ejemplo, decimos en vez de 20 ejes, en 19 voy a añadir uno más, 00:35:47

que lo que hace es añadir otro al final duplicado del último que había. 00:35:52

Decimos, este eje se va a llamar, y hemos dicho aquí, rotando. 00:35:56

De manera idéntica, si ponemos rotando, ahora lo que podremos hacer es decir, 00:36:01

borro los valores y decimos, el valor negativo va a ser la tecla R, ¿vale? 00:36:08

La tecla R. Y el valor positivo, la T. 00:36:15

Y aquí la gravedad, para que sea parecida a la que había, le vamos a poner 3 y 3, 00:36:18

que son los valores que había. 00:36:23

Lo que pasa es que he generado otro axis, que se controla con otras teclas, 00:36:25

y yo lo puedo llamar con la variable data, que está recogiendo lo que hagamos en ese nuevo axis 00:36:29

llamado rotando, que hemos creado. 00:36:37

Si ahora, en vez de usar el desplazamiento X, decimos que lo haga en función del input RotateData, 00:36:40

ahora mismo lo que hemos hecho es que hemos diversificado, hemos separado esta acción 00:36:50

en dos acciones independientes y en dos inputs independientes. 00:36:56

¿Qué significa esto? 00:36:59

Si yo doy a derecha e izquierda, no rota nada. 00:37:01

Tengo también la subida y la bajada, porque también estaba configurada en otro momento del código, 00:37:05

en lo que había pasado el compañero. 00:37:09

Pero si yo doy a la R, hará esta rotación a la izquierda, 00:37:11

y luego, independientemente, yo puedo mover con las otras teclas, 00:37:15

con la cruceta, en este caso, izquierda-derecha. 00:37:18

Si quiero que vaya derecha la nave, es decir, que rote, le daré a la T. 00:37:20

Y tengo controles independientes. Puedo subir y bajar y a la vez rotar. 00:37:26

Problema. Y otra vez volvemos. 00:37:32

Cuando rotamos y le damos arriba y abajo, vemos que ahora lo hace con respecto a la nave. 00:37:34

Esto ya lo sabríamos solucionar, porque lo que está pasando es que yo aquí le he dicho 00:37:40

que sean los ejes del mundo los que permitan calcular este Translate, 00:37:44

pero en el de vertical está cogiendo el Self por defecto. 00:37:50

Entonces habría que volver a decirle que este movimiento también es en base 00:37:56

a las coordenadas del mundo. 00:38:00

Entonces ahora, ya con este cambio, nuevamente subimos y bajamos. 00:38:03

Y si rotamos, subimos y bajamos con respecto a los ejes globales del mundo. 00:38:08

¿Qué tal hasta aquí? Más o menos. 00:38:14

Sé que lo del Euler angle de antes, no sé qué ha pasado. 00:38:18

Pero a ver, ¿la aceleración es de esa aceleración que tiene al moverse esa automática 00:38:22

o hay que configurarla? 00:38:28

Eso es lo que he explicado. Entiendo que te lo he respondido posteriormente, 00:38:30

que no te había leído. 00:38:34

Se modifica con la sensibilidad del Input. 00:38:37

Es cierto que esto, ya te digo, la solución que estaba dando al principio con el Rotate 00:38:42

en vez de asistir directamente a los ángulos, debería funcionar. 00:38:47

Entonces le podría dar vueltas, pero le voy a dar una última vuelta muy rápida. 00:38:56

Si tenéis alguna duda más, sobre todo quien lo haya intentado, que me la pregunte. 00:39:01

Si no, ahora seguimos hablando de otras cosas sutiles. 00:39:06

Pero permitidme un segundo porque ya me ha tocado un poco la moral. 00:39:09

Que si es menor de 45. 00:39:15

Ahora me está dando como que no me coge los Euler angles. 00:39:21

Ah, vale, claro, porque hay que decirle un eje, eje Z. 00:39:24

Y este B. 00:39:28

Si yo aquí le estoy diciendo... 00:39:32

Si la rotación es menor que... 00:39:36

Y teníamos, a ver, que copio la línea literal que tenías tú puesta, 00:39:40

porque estaba bien planteada. 00:39:44

A ver dónde tengo yo esto. Ah, que me salía. 00:39:48

Estaba en el foro, aquí. 00:39:54

Vamos allí. 00:39:56

Lo tenías con un Translate Vector Back, que no debería dar problema. 00:39:58

Tengo aquí un jaleo de botones. 00:40:07

Haría una rotación, es decir, que por cada unidad de tiempo que se estuviera cumpliendo esto, 00:40:10

habría un Vector Back. 00:40:16

Ahora vamos a decirle, por ejemplo, un Rotate Data. 00:40:18

Y a ver si va a ser esto lo que está ocurriendo. 00:40:21

Y me cargo el TimeDeltaTime. 00:40:24

A ver si con esto lo conseguimos. 00:40:27

Que yo creo que si no funciona antes, tampoco va a funcionar. 00:40:30

A ver, perdonad, ¿eh? 00:40:34

Ahora mismo estamos diciendo, por decir, si sobrepasa los 45 grados, 00:40:37

en Z, pues ya no se ejecuta la rotación. 00:40:43

Mientras sí que esté por debajo de los 45, se debería rotar. 00:40:47

Y la rotación lo que voy a hacer es que cuando empiece el juego, 00:40:51

cuando lo arranque, voy a poner un Start para asegurarme, 00:40:56

aunque lo estemos controlando ahora en el editor de Unity, 00:41:00

que la rotación valga 100, algo bastante elevado, 00:41:03

para que sin duda lo coja y no se queje esta un valor muy pequeño. 00:41:07

Que a veces sucede eso también, ¿no? 00:41:11

Entonces lo he guardado. 00:41:13

Y si volvemos ahí... 00:41:15

He borrado lo que tenía hasta ahora. 00:41:17

Lo he comentado. 00:41:19

Comento esto, que si no, no estamos viendo lo que quiero ver. 00:41:21

Y si ahora le doy... Vamos a ver. 00:41:26

Pues nada, que no quiere. 00:41:32

A ver, estamos en una prepa... 00:41:34

Ah, vale. 00:41:40

Vale, sí, sí, sí, sí lo ha hecho. 00:41:41

Lo que pasa es que no estaba usando el Rotate. 00:41:43

Porque ahora lo tengo configurado. 00:41:47

Estaba dando izquierda-derecha, pero ahora el Rotate se hace con R y T, 00:41:49

que es lo que tengo, hasta que no le he dado a eso. 00:41:52

Vale, ya lo está empezando a hacer. 00:41:54

Ya decía yo que algo pasaba. 00:41:56

Ahora lo que habría que decir es que cuando hagamos esto, 00:41:58

Transform, Rotate, 00:42:02

si es menor que 45, pues que me deje rotar. 00:42:06

Y si no, pues... 00:42:09

Si no, pues le decimos que... 00:42:16

Le decimos que el valor del Transform, 00:42:21

igual que has hecho aquí, digamos que se ancle en un valor, 00:42:25

que es igual a 45. 00:42:28

Transform... 00:42:34

Ahora hay que decirle que si no, 00:42:37

que el Transform Z sea de 45. 00:42:39

¿Y por qué ahora me está dando este fallo? 00:42:45

Cuando tengáis un problema de un error, 00:42:49

si le dais doble clic, debería enseñarlo. 00:42:52

Ah, vale, lo tengo en otro panel. 00:42:56

Ah, vale, sí. 00:43:02

Pero nada, que es que aquí tengo... 00:43:05

Digamos que esto es una ventana del Visual Studio, 00:43:07

pero cuando le dais a esto de los errores, 00:43:09

hay una ventana que se llama Lista de Errores, 00:43:11

que te enseña el error. 00:43:13

Y te está diciendo, básicamente, 00:43:15

lo que me está diciendo, que probablemente la base del error es 00:43:17

no se puede modificar el valor devuelto, 00:43:20

Transform, Element Angles, porque no es una variable. 00:43:22

Entonces, cuando queramos apelar 00:43:26

o cambiar directamente uno de estos ejes, 00:43:28

nos está pidiendo que sea una variable. 00:43:30

Entonces, lo que habrá que decirle, 00:43:32

aunque no debería ocurrir esto, 00:43:34

porque si le estamos diciendo que 00:43:37

este valor se convierta en 45, 00:43:40

habrá que decirle, si no, 00:43:45

si no se cumple esto, 00:43:47

los... 00:43:50

Valor debe valer 45. 00:43:52

Vale. 00:43:56

A ver... 00:43:58

Un segundito... 00:44:00

Vale, no se puede cambiar directamente 00:44:02

uno de los ejes del vector, claro. 00:44:05

Entonces, habrá que hacer, 00:44:09

igual que ha hecho aquí el compañero, 00:44:11

que el ángulo de esta nave, 00:44:13

cuando es menor de 45, 00:44:16

es decir, cuando sobrepasa 00:44:18

o estamos intentando sobrepasar un ángulo, 00:44:20

pues habrá que decirle, 00:44:23

el vector de esta nave, 00:44:25

cómo se declara un vector, 00:44:28

que siempre hay que poner este new, 00:44:30

porque estamos generando una nueva coordenada, 00:44:32

con los vectores siempre hay que poner esto de new normalmente, 00:44:34

aunque se esté refrescando todo el rato 00:44:37

el valor de la misma variable, 00:44:39

se está refrescando en cada momento, 00:44:43

por eso hay que poner la palabra clave new. 00:44:45

Entonces habrá que decir, 00:44:47

que el transform.EbullierAngles, 00:44:49

a ver... 00:44:53

EbullierAngles en X sea el que tiene, 00:44:55

en Y va a ser también el que tenga ya, 00:44:59

para que no se varíe el que tiene por defecto, 00:45:03

aunque en este momento podríamos poner 0, 00:45:05

porque se va a mantener en 0, 00:45:07

y este va a ser de 45. 00:45:09

Ahí lo tenemos. 00:45:12

Veis que a veces es ver por qué está fallando algo, 00:45:14

e intentar reubicarlo de otra forma. 00:45:16

Ahora, si el ángulo es menor de 45, 00:45:19

pues valdrá 45, porque no va a dejar. 00:45:24

El problema es que si es menor de 45 hace esto, 00:45:29

pero como aquí estamos diciéndole que sea 45, 00:45:32

habrá que decirle que sea menor o igual a 45, 00:45:35

porque si no, esta condición puede entrar en conflicto. 00:45:38

Entonces, vamos allá. 00:45:41

A ver cómo va la rotación ahora. 00:45:43

Empezamos, se mueve a derecha e izquierda, 00:45:48

y ahora la rotación, si le doy a R, placa. 00:45:51

Le estoy dando, 00:45:54

y llega a este punto y ya no prosigue. 00:45:56

¿Qué pasa? Que cuando yo le intento dar a T, 00:46:00

también debería hacer la rotación a la inversa, 00:46:03

porque al final aquí lo que estoy haciendo es meter un valor 00:46:08

que puede ser por 1, 00:46:13

y entonces el vector debería ir a la derecha. 00:46:16

La cosa es que si yo tengo este valor aquí igual a 45, 00:46:19

me debería permitir hacerlo. 00:46:25

A ver qué es lo que está ocurriendo. 00:46:27

A ver, un segundo. 00:46:29

Y si le doy la rotación en el otro sentido... 00:46:31

¿Qué es lo que ocurre? 00:46:35

Que si es menor o igual a 45, pasa esto, 00:46:37

pero también habrá que definir el rango en positivo. 00:46:40

Es decir, si el Transfer Euler Angles es menor o igual a 45, 00:46:43

y también... 00:46:49

Claro, aquí va a ocurrir otro problema. 00:46:53

El Transfer Euler Angles es menor o igual a 45, 00:46:57

y también es... 00:47:02

Esto el otro día dijimos que podríamos poner más de una condición, 00:47:05

y esto también es un Transfer Euler Angles 00:47:09

que sea mayor o igual a menos 45, que es lo inverso, 00:47:16

te deja hacer esta condición. 00:47:23

¿Vale? 00:47:26

Entonces, ¿qué es lo que ocurre? 00:47:27

Que ahora el problema es que aunque ahora me debería dejar 00:47:30

moverme en las dos direcciones, y ahí se queda estancado, 00:47:33

y bueno, va a haber más problemas. 00:47:36

Pero ahora se ha puesto en 45, 00:47:39

porque en cuanto me paso de uno de estos valores me dice 45. 00:47:41

Por tanto, la solución no puede ser esta. 00:47:44

A ver, cuidado. 00:47:47

Porque en cuanto me pase me lo pone en menos 45, 00:47:48

y ya puede generar problemas. 00:47:51

También aparte, en rotación, 00:47:53

le dije un valor de 100. 00:47:57

Le voy a poner 1 para que se vea un poco 00:47:59

el proceso de llegar a ese momento en el que todo se estropea. 00:48:02

A ver... 00:48:06

Un segundo. 00:48:09

Porque esto es un Rotate, 00:48:11

y debería ir sumando por rotación por Rotate Data. 00:48:13

A ver... 00:48:18

Rotate Data Time. 00:48:21

Un segundillo. 00:48:24

¿Y por qué lo hace instantáneo? 00:48:31

Vale. 00:48:38

Ya está empezando a detectar ciertos valores. 00:48:40

Menos 45 y mayor que menos 45. 00:48:45

Y hay una cosa que también hay que tener en cuenta. 00:48:50

A ver... 00:48:53

Que es lo que estamos usando, 00:48:59

y esto también es algo a tener en cuenta. 00:49:01

Rotación... 00:49:06

El Time Delta Time no debería tener tanta influencia aquí. 00:49:07

Porque... 00:49:12

En realidad sí que está bien puesto. 00:49:14

Tengo que ponerle un valor más alto. 00:49:16

Ajá. 00:49:20

Y ahora me lo está cogiendo directamente como 45. 00:49:25

Vale. 00:49:28

Aquí habría que darle más vueltas, 00:49:29

porque también habría que decir, 00:49:31

oye, claro, 00:49:34

si estoy entre esta posición y esta posición, 00:49:38

directamente habrá que detectar 00:49:41

si el extremo que estoy llegando es uno o es otro. 00:49:43

Por tanto, unir las dos condiciones en una es peligroso. 00:49:46

Porque, básicamente, si llego al menos 45, 00:49:50

no quiero que me lo ponga en 45. 00:49:53

Entonces, lo que habría que hacer, básicamente, 00:49:55

es dividir esto en dos condiciones 00:49:58

que, entre ellas, puedan completar 00:50:02

todo el rango de lo que está buscando. 00:50:08

Entonces, a ver... 00:50:12

Y sería un poco replicar esto. 00:50:17

Si también se da la condición de que es mayor que menos 45... 00:50:19

¿Vale? 00:50:25

Si es mayor que más 45... 00:50:27

El problema es que estas dos condiciones se contradicen. 00:50:30

Si es menor de 45, deja rotar. 00:50:34

Y si es mayor de menos 45, déjame rotar. 00:50:36

Por tanto, siempre se va a cumplir esta rotación. 00:50:38

¿Vale? 00:50:42

Porque, aunque me la esté bloqueando, 00:50:43

luego paso a esta y está ocurriendo. 00:50:45

Entonces, ¿qué es lo que hay que hacer? 00:50:47

Pues acudir a booleanos. 00:50:49

Es decir, que cuando la condición se esté dando, 00:50:51

si llega al punto en el que esto no se está dando 00:50:57

y, por tanto, no puedo rotar, 00:50:59

aparte de bloqueármelo en un punto, 00:51:01

en el máximo que estemos poniendo, 00:51:04

le voy a decir bloqueo rotación. 00:51:06

Por ejemplo, una variable que aún no existe, 00:51:10

pero que la voy a crear ahora mismo. 00:51:13

True. 00:51:15

Es decir, que cuando llegue a una situación 00:51:16

en la que no debería moverse, 00:51:18

yo bloqueo la rotación. 00:51:20

Entonces, yo aquí voy a hacer una variable global 00:51:22

que sea bool bloqueo rotación. 00:51:26

Y por defecto... 00:51:30

Bueno, me voy a poner por defecto. 00:51:32

Y por defecto va a ser falsa, 00:51:34

porque yo no quiero que esté bloqueado. 00:51:35

Empieza desbloqueado esto, ¿no? 00:51:38

Falsa, no quiero que haya bloqueo. 00:51:40

Entonces, cuando se incumpla esta condición, 00:51:42

digo, no, no, esto se bloquea. 00:51:45

Eso sí, mientras sí se puede hacer, 00:51:47

el bloqueo de rotación está en falso, 00:51:49

no está bloqueado. 00:51:53

Y cuando llegamos a la segunda, 00:51:55

lo que habrá que decirle es 00:51:57

si bloqueo rotación es diferente a verdadero, 00:51:58

o mejor aún, decimos que es igual a falso, 00:52:11

es decir, que no está bloqueado, 00:52:13

es igual a falso. 00:52:15

Entonces, sí que permite hacer la rotación. 00:52:17

Si no, como en este momento 00:52:23

no se está guardando como true, 00:52:25

pues no sucederá esto. 00:52:27

Si esto no se cumple además, 00:52:31

pues vamos a hacer otro else 00:52:34

en el que lo que haga es decir 00:52:36

que el ángulo que le da es menos 45, 00:52:39

que es en el que Cremge lo bloquee, 00:52:41

y el bloqueo de rotación sí que se estanca ahí 00:52:43

hasta que nuevamente se vuelva a cumplir la condición. 00:52:47

Entonces, aquí bloqueo de rotación, 00:52:51

nuevamente habría que hacer un false. 00:52:53

Esta es una solución que estoy llegando ahora 00:52:55

y hay que ver si funciona. 00:52:57

Pero lo que más me interesa 00:52:59

es que vayáis viendo un poco la lógica 00:53:00

que voy siguiendo para que se cumpla. 00:53:02

Probablemente, ya os digo, 00:53:04

con la rotación es más complicado 00:53:05

pero aquí me está poniendo menos 45 por defecto. 00:53:08

Y esto no debería ser así 00:53:14

porque por defecto lo voy a poner en cero, 00:53:16

que en algún momento he cambiado la variable 00:53:20

según arrancaba. 00:53:22

Y aquí esto mayor o igual a menos 45, 00:53:24

que es que había una condición 00:53:29

que no estaba bien escrita y daba error. 00:53:31

Ahora debería empezar en cero 00:53:34

hasta que yo no rote un poco. 00:53:36

No me deja variar. 00:53:38

Ahora lo bueno es que ya me deja rotar 00:53:42

pero hay un momento aquí, si os fijáis, 00:53:45

que se le va un poco la pinza 00:53:48

y va a menos 45 y rota directamente. 00:53:51

¿Qué problema hay con las rotaciones? 00:53:55

¿Qué es lo que está dando este problema? 00:53:57

A ver... 00:53:59

¿Qué? 00:54:01

Y esto también es para que lo tengáis en cuenta. 00:54:02

Que los valores negativos 00:54:04

realmente tienen 360 grados, 00:54:06

las rotaciones en cada uno de los ejes. 00:54:09

Y aunque pongamos aquí menos 45, 00:54:12

en realidad, 00:54:15

aunque aquí veamos menos 45, 00:54:17

esto es menos 45, vais a ver, 00:54:20

que es equivalente a poner 360 menos 45. 00:54:24

Que cuando yo doy es 315. 00:54:32

Internamente, estos ejes, 00:54:34

cuando pasan de 360, aunque se vayan sumando, 00:54:36

se van realizando en ejes de 360. 00:54:40

Entonces, no habría que hacer 00:54:43

en cuanto esto sea mayor a menos 45, 00:54:45

sino cuando sea mayor a 300. 00:54:49

Hemos dicho... 00:54:51

A ver, espera... 00:54:53

¿315 era? Sí. 00:54:55

Vale, 315. 00:54:57

Si es mayor a 315... 00:55:00

Yo esto lo fijo en menos 45. 00:55:04

A ver cómo funciona ahora. 00:55:07

La solución que os he dado antes 00:55:12

era la más sencilla, en el sentido de que 00:55:14

no tenemos que realmente lidiar mucho 00:55:16

con los ángulos en sí. 00:55:19

Porque simplemente lo que hacíamos era decirle 00:55:21

remito a esas tres dimensiones 00:55:23

de los ángulos, de los ejes, 00:55:26

pero luego, básicamente, 00:55:28

lo que estoy haciendo es cambiarlo 00:55:30

por la rotación que estemos dando en el eje 00:55:32

y con un límite que tenemos ahí. 00:55:36

Entonces, yo ahora mismo... 00:55:38

Vamos a ver... 00:55:40

He vuelto a ponerse en un eje. 00:55:42

Porque, nuevamente, 00:55:44

al sumar, al decirle que es mayor 00:55:46

de 315, 00:55:50

se está cumpliendo una condición. 00:55:52

Vale, que esto debería estar en 315. 00:55:55

A ver... 00:56:00

¿Y por qué...? 00:56:03

Ah, vale, porque había cambiado 00:56:05

para hacer la prueba. 00:56:07

Y aquí... 00:56:09

Sí, así debería funcionar. 00:56:11

Vale, ahí vamos a ello. 00:56:14

Vale. 00:56:18

¿Y por qué se me pone en menos 45? 00:56:20

Pues hay que ir depurando esto 00:56:22

a ver cómo se consigue. 00:56:24

Habría que darle unas vueltas. 00:56:26

Pues ya os digo, el problema está 00:56:28

sobre todo con cómo interpreta los ejes. 00:56:30

Pero fijaos en que, 00:56:34

aunque se le va un poco la cabeza, 00:56:36

la importancia de los booleanos 00:56:38

para ir en las condiciones. 00:56:40

Cuando vamos encadenando varios ifs, 00:56:42

por ejemplo, pues ir discriminando 00:56:44

que algo funcione o no funcione. 00:56:46

Vale. 00:56:49

Más dudas, ya os digo, 00:56:51

la solución que podría plantearse es esta, 00:56:53

que os he comentado antes. 00:56:55

Hay otra solución intermedia, 00:56:57

que es en otra nave 00:57:03

que yo tengo aquí preparada. 00:57:05

Y, ojo, otra cosa importante 00:57:07

que quería en relación 00:57:09

a lo que ha compartido el compañero, 00:57:11

es que si os fijáis a veces 00:57:13

que estáis usando los mismos números 00:57:15

en muchas ocasiones, 00:57:17

y esto lo ha hecho el compañero, 00:57:19

para poner unos límites 00:57:21

y la nave no pueda subir 00:57:23

más de una posición o menos de una posición, 00:57:25

es, en vez de poner el número varias veces, 00:57:27

que si lo cambiáramos una vez, 00:57:29

pues igual que estamos haciendo aquí 00:57:31

con los ángulos, vaya. 00:57:33

Si, por ejemplo, 00:57:37

cambiamos el límite inferior, 00:57:39

pues aquí podemos decir, 00:57:41

vamos a crear una variable, 00:57:43

vamos a poner un float, 00:57:45

y se llame límite superior, 00:57:47

y que sea de, bueno, 00:57:51

este sería inferior, pero vamos, 00:57:53

de, bueno, y en X además, 00:57:55

como es simétrico, no es superior, 00:57:57

el límite lateral, 00:57:59

pues que sea 23. 00:58:01

¿Vale? Ahora, 00:58:07

a ver, que no lo estoy escribiendo nada bien, 00:58:09

ahora aquí lo que podemos hacer 00:58:11

es decir, vale, pues, 00:58:13

de una forma muy rápida, siempre que 00:58:15

quiera aludir a los límites laterales, 00:58:17

y además, aquí lo ha hecho con mucho 00:58:19

tino, es, como es simétrico, 00:58:21

porque el juego empieza desde el cero, 00:58:23

si lo hemos ubicado bien, los límites de la derecha 00:58:25

y la izquierda, si queremos que sea simétrico, 00:58:27

van a ser el mismo, solo va a cambiar el sentido 00:58:29

de ese límite. Pues lo que 00:58:31

podemos hacer aquí es 00:58:33

cambiarlo 00:58:35

todo con el límite lateral, y con el menos 00:58:37

invertimos el sentido 00:58:39

de ese límite. 00:58:41

Pero aquí, si en cualquier momento dijéramos, en vez de 25 00:58:43

son 28, ya se ha cambiado 00:58:45

automáticamente en todo. 00:58:47

Igual podría pasar con el límite superior 00:58:49

con el inferior, ¿vale? Es verdad que el límite superior 00:58:51

y el inferior quizá no sea tan simétrico, 00:58:53

y el superior sean 00:58:55

100 y el inferior menos 10. 00:58:57

Bueno, pues lo que podemos hacer es hacer 00:58:59

un límite superior 00:59:01

y uno inferior, pero al menos, si cambiamos uno, 00:59:03

el otro también se ve reflejado. 00:59:05

Hay que intentar usar 00:59:07

las variables y reciclarlas, reutilizarlas 00:59:09

en base a 00:59:11

variables, ¿no? 00:59:15

Que nos simplifica un poco 00:59:17

todo esto. Igual que 00:59:19

en el update, para limpiarlo un poco, 00:59:21

igual que podría 00:59:23

hacer con la rotación, lo que 00:59:25

podemos hacer es resumirlo en 00:59:27

un método. Como vimos el otro día 00:59:29

cuando estuvimos hablando de la creación 00:59:31

de métodos 00:59:33

en la última tutoría de la UT0, 00:59:35

vimos que para agrupar 00:59:37

y que se dieran en varias ocasiones 00:59:39

el mismo código sin tener que escribirlo, 00:59:41

o para que quede más limpio el update, 00:59:43

que al final es una parte fundamental, luego a leer, 00:59:45

lo que podemos hacer es crear 00:59:47

métodos, 00:59:49

en este caso un void, 00:59:51

que sea chequear 00:59:53

límites, ¿vale? 00:59:55

Y lo que hacemos es que aquí 00:59:57

a ver, perdonad que se me ha metido, 00:59:59

aquí, ¿vale? 01:00:01

Lo que vamos a hacer es copiar ese código 01:00:03

que va a estar todo el rato ejecutando, no sé si apelamos 01:00:05

a ese método, pero está independiente 01:00:07

y podemos ir modularizando 01:00:09

el código 01:00:11

para que luego sea más fácil 01:00:13

comprobarlo, ¿vale? Ahora mismo 01:00:15

si aquí decimos que en el update cada fotograma 01:00:17

haga un 01:00:19

chequeo de los límites, 01:00:21

pues es exactamente lo mismo que 01:00:23

teníamos antes. En todo momento está viendo 01:00:25

dentro de aquí, no hay ninguna condición 01:00:27

más allá de esta que diga que 01:00:29

no se ejecute chequear límites en cada 01:00:31

fotograma, y de esta forma podemos 01:00:33

ir a hacer un 01:00:35

apartado de chequear límites, 01:00:37

otro apartado de 01:00:39

la rotación, ¿vale? 01:00:41

Eso está bien para ir organizando 01:00:43

también un poco el código, 01:00:45

¿vale? 01:00:47

Lo que voy a 01:00:49

hacer también... Bueno, ¿qué tal 01:00:51

hasta aquí? Sé que 01:00:53

igual está siendo un poco farragoso porque no me 01:00:55

está saliendo lo de los ángulos, 01:00:57

pero bueno, una solución 01:00:59

que ya tenéis, y también una forma 01:01:01

de usar los input managers 01:01:03

de manera consciente 01:01:05

de que hay un tiempo, un periodo, entre que 01:01:07

se va de un punto a otro 01:01:09

de lo que hagamos 01:01:11

en los axis. 01:01:13

¿Alguien ha levantado la mano, si no me equivoco? 01:01:17

Ah, vale, que la has dado sin querer. 01:01:23

Vale, genial. 01:01:25

Vale. 01:01:27

Vale, pues si le puedes volver a dar la manita y así se me 01:01:29

quita, por si lo quieres volver 01:01:31

a pedir en la palabra. Vale, 01:01:33

perfecto, ya está. 01:01:35

¿Alguna cosa concreta 01:01:37

más? Aparte de... Ahora podemos ver 01:01:39

alguna 01:01:41

duda más que tengáis, etcétera. 01:01:43

Francisco, Javier, ¿qué tal? 01:01:47

Perdona que te llame así. Si 01:01:49

quieres dime cómo me refiero a ti. 01:01:51

Javier, Javier. 01:01:53

Igual otro día se me olvide 01:01:55

y te pregunto lo mismo, pero vale. Hoy, Javier. 01:01:57

¿Más o menos con esto 01:01:59

ya sabrías continuar 01:02:01

con lo que te he dicho, no? 01:02:03

Sí, yo creo que sí. Más o menos lo podría 01:02:05

solucionar. Un poco complicado, la verdad, porque esto a mí 01:02:07

se me está haciendo eterno 01:02:09

lo del tema 01:02:11

de esto del videojuego, pero bueno. 01:02:13

Yo creo que sí lo podría hacer. Gracias. 01:02:15

Vale, ¿y lo que es el seguimiento de cámara, 01:02:17

etcétera? 01:02:19

Eso más o menos... 01:02:21

Es que con el seguimiento de cámara he visto que hay... 01:02:23

Perdón, a ver. 01:02:25

Sí, te oigo, te oigo. 01:02:27

Es que he visto 01:02:29

en internet que hay 01:02:31

varios métodos para el seguimiento de cámara. Uno 01:02:33

con el LUCAT y he visto diferentes formas 01:02:35

también para hacerlo. Vale. 01:02:37

Perfecto. Os voy a 01:02:39

decir una que sirve para explicar 01:02:41

el smooth damp, que es 01:02:43

algo que se podría usar también 01:02:45

para el 01:02:47

suavizado de la rotación de 01:02:49

la nave. Entonces, 01:02:51

al final del tema se 01:02:53

habla de métodos de interpolación, 01:02:55

como ese smooth damp. 01:02:57

Si no tenéis otra duda, voy a pasar a 01:02:59

explicar un poco sobre ello. 01:03:01

Porque sí que es un método que sirve para 01:03:03

suavizar valores 01:03:05

entre sí y creo que es interesante. 01:03:07

Entonces, 01:03:09

voy a desactivar tu nave y voy a volver a 01:03:11

una que tengo por aquí. 01:03:13

Y bueno, lo primero, 01:03:15

Javier, normal que se te haga 01:03:17

largo. Es decir, son tareas que 01:03:19

implican 01:03:21

bastante trabajo. No sé si 01:03:23

preferís que la retrase a lo mejor una 01:03:25

semana, porque sinceramente, este 01:03:27

domingo me entregáis los que lo hagáis, la de RMPA 01:03:29

y coincide con la 01:03:31

de DAME y la semana que viene tengo muchas cosas de 01:03:33

proyectos y no creo que me dé tiempo a corregirlas. 01:03:35

Si queréis la retrasa una semana, si 01:03:37

le queréis dar más plazo, 01:03:39

lo que pasa es que me interesa también 01:03:41

que 01:03:43

me interesa también 01:03:45

que vayáis intentando 01:03:47

también pasar a la de la unidad 3 01:03:49

que digamos que implica cosas de esto 01:03:51

pero también implica otras cosas. 01:03:53

Entonces son diferentes 01:03:55

abordajes 01:03:57

del movimiento, 01:03:59

etcétera. 01:04:01

Sí, Daniel, es bastante 01:04:05

denso. 01:04:07

Sí, no te voy a engañar. 01:04:09

Sí lo es. 01:04:11

Tiene sus 01:04:13

pegas y tiene sus 01:04:15

explicaciones. Pero bueno, es 01:04:17

que poco a poco vayamos comprendiendo cómo se van 01:04:19

haciendo y las dudas, nuevamente, 01:04:21

las vayáis planteando 01:04:23

en el foro. 01:04:25

Sobre el seguimiento de la cámara. 01:04:27

Lo que ocurre, 01:04:31

lo que se puede hacer, incluso sin 01:04:33

meter mucho código, 01:04:35

es decir... 01:04:37

Voy a hacer una escena rápidamente. 01:04:39

Voy a hacer una 01:04:43

escena nueva, como otro juego, 01:04:45

otro nivel. 01:04:47

Para enseñar esto, escena 01:04:51

prueba cámara, lo voy a llamar. 01:04:53

Me sale un momento de esta escena, 01:04:55

voy a otra, está vacía. 01:04:57

Imaginaos que yo meto la nave, 01:04:59

meto la nave, el prefab que tengo aquí, 01:05:05

lo incorporo aquí. 01:05:07

El otro día se quedó aquí con 01:05:09

una cosa movida para explicaros 01:05:11

y ahí se ha quedado. 01:05:13

El problema es X. 01:05:19

Lo guardo el prefab y así 01:05:21

ya lo tenemos. 01:05:23

Meto esta nave y yo tengo 01:05:25

una cámara que 01:05:27

cuando vemos el juego no se está viendo nada. 01:05:29

¿Qué significa eso? Que la cámara 01:05:31

no está en las coordenadas 01:05:33

que debe estar para que se vea 01:05:35

algo relacionado 01:05:37

con el juego. 01:05:39

Cuando arrastramos un elemento al prefab, cuidado, 01:05:41

porque puede tener 01:05:43

coordenadas ya preestablecidas. 01:05:45

Esto es lo que os expliqué el otro día. 01:05:47

Pueden estar movidas de situación. 01:05:49

La cámara se va a ver 01:05:51

en relación a sus coordenadas 01:05:53

y se puede operar con ella 01:05:55

igual que se hace con cualquier 01:05:57

GameObject. 01:05:59

¿Qué pasa si yo empiezo a mover 01:06:01

durante el juego? 01:06:03

Con código, como estáis 01:06:05

elaborando, si yo empiezo 01:06:07

a mover 01:06:09

el objeto, 01:06:11

la cámara se queda en su sitio, en ningún momento 01:06:13

se está moviendo. 01:06:15

Voy a poner un suelo 01:06:17

o algo que dé una referencia 01:06:19

del espacio, porque ahora mismo, como no hay 01:06:21

nada, no sabemos si está subiendo o bajando 01:06:23

más allá de que se está 01:06:25

alejando de la cámara. Voy a poner aquí un plano 01:06:27

que sirve si le damos 01:06:29

unas... lo voy a poner en 0, 0, 0 01:06:31

por ejemplo. 01:06:33

Es así como podríais crear el suelo de este nivel. 01:06:35

Y le damos una escala 01:06:37

de 100 por 100. 01:06:39

Ahí tenemos un suelo. 01:06:41

Ahora mismo, si yo 01:06:43

arranco el juego 01:06:45

y desde la escena 01:06:47

yo puedo simular que estoy moviendo el juego 01:06:49

veis que se está viendo en todo 01:06:51

momento moverse la 01:06:53

nave 01:06:55

pero la cámara no la está siguiendo. 01:06:57

Es un poco lo que se pide. 01:06:59

Hay una solución muy rápida 01:07:01

que es hacer 01:07:03

a la cámara hija de la nave. 01:07:05

¿Eso qué significa? 01:07:07

La hacemos hija. Está dentro 01:07:09

en la jerarquía. 01:07:11

¿Qué significa? Que cuando yo mueva 01:07:13

está... 01:07:15

a ver... 01:07:17

Está la cámara 01:07:19

y tiene que ser hija de él. 01:07:21

Ah, vale. 01:07:23

Es que la ha metido en el prefab. 01:07:25

Un segundín. 01:07:27

Tengo aquí prefab. Si la hago hija del prefab 01:07:29

ahora sí que debería 01:07:31

moverse con el prefab. 01:07:33

Si muevo el prefab 01:07:35

veréis que lo que se está 01:07:37

moviendo es la cámara también y por eso parece 01:07:39

que se aleja del suelo. 01:07:41

El problema de esto es 01:07:43

que no lo estamos controlando por código 01:07:45

y en cualquier momento que queramos que se aleje 01:07:47

o se acerque 01:07:49

se está heredando las coordenadas 01:07:51

del padre del prefab 01:07:53

pero no estamos teniendo un control. 01:07:55

Y además una de las cosas que se 01:07:57

pide en el enunciado 01:07:59

es 01:08:01

que metamos una interpolación 01:08:03

de la posición de la cámara. 01:08:07

Para que se vea mejor esto 01:08:09

también os voy a 01:08:11

introducir ya una cosa aquí 01:08:13

que lo explico muy rápido que es 01:08:15

cómo generar un material con un color 01:08:17

para que no sea este blanco porque ahora mismo 01:08:19

este suelo, por ejemplo, 01:08:21

no me interesa mucho que sea blanco porque 01:08:23

no se ve claramente dónde estamos. 01:08:25

Podemos generar 01:08:27

por ejemplo, con clic derecho 01:08:29

en crear, igual que hacemos 01:08:31

los scripts o hacemos 01:08:33

muchas otras cuestiones, 01:08:35

por decir que se cree un material 01:08:37

que voy a llamar 01:08:39

superficie 01:08:41

porque tengo otro suelo por ahí, 01:08:43

otro material ya creado, superficie. 01:08:45

Y en las opciones del inspector 01:08:47

esto también si habéis ya usado software 01:08:49

de 3D 01:08:51

es como generar un material 01:08:53

en Maya o en otros 01:08:55

Así por defecto en este momento solo me voy a centrar 01:08:57

en una cosa que es que 01:08:59

puedo cambiar aquí el color del material 01:09:01

y por ejemplo lo voy a poner este en rojo 01:09:03

apagado, 01:09:05

casi negro, y aquí pues 01:09:07

el material tiene ese valor. ¿Cómo se aplica 01:09:09

un material? Pues arrastrando 01:09:11

de aquí, lo suyo sería hacer una carpeta 01:09:13

de materiales que aquí la tengo, pues arrastrarlo 01:09:15

para tenerlo organizado, pues 01:09:17

arrastro al elemento que 01:09:19

quiero que sea de ese color. 01:09:21

Y quiero que os fijéis en que 01:09:23

si yo tengo ese 01:09:25

cualquier elemento 01:09:27

pues tendrá un mesh renderer 01:09:29

que es lo que hace que 01:09:31

se visualice, si no, no se está 01:09:33

visualizando, es el componente que 01:09:35

permite que algo se vea. 01:09:37

Si yo voy a los materiales, por defecto se pone 01:09:39

este material default, que es 01:09:41

este blanco que se aplica a todo. 01:09:43

Si yo arrastro 01:09:45

aquí o aquí también 01:09:47

lo que estoy haciendo es que el material, lo hago 01:09:49

directamente en el viewer, 01:09:51

cogiendo ese material. Con eso ya podéis ir 01:09:53

asignando a cada 01:09:55

uno de los elementos que 01:09:57

tenga mesh renderer, un material. Evidentemente 01:09:59

luego los materiales, ya lo veremos 01:10:01

más adelante, tienen 01:10:03

bastante 01:10:05

bastante canal, 01:10:11

bastante parámetro que se puede modificar 01:10:13

para que sea más metálico, para que 01:10:15

tenga rugosidades, etc. Pero esto 01:10:17

ya lo veremos en 01:10:19

otro momento. Ahora mismo 01:10:21

si yo la cámara la 01:10:23

hago hija de 01:10:25

este prefab, 01:10:27

cuando yo mueva el 01:10:29

prefab, la cámara se está moviendo 01:10:31

porque hereda la posición 01:10:33

del prefab. Se va moviendo el 01:10:35

suelo también. No es que se mueva 01:10:37

el suelo, sino que se está moviendo la cámara. 01:10:39

Esta no es la manera 01:10:41

óptima porque nos puede interesar 01:10:43

que la cámara 01:10:45

pulsando una tecla 01:10:47

se coloque en otra posición y se aleje. 01:10:49

Como en algunos videojuegos que 01:10:51

van dando a la V 01:10:53

y puede ir 01:10:55

moviéndose a distintos puntos del 01:10:57

juego. Luego veremos 01:10:59

también que hay un paquete 01:11:01

que se llama Cinemachine, lo veremos más adelante, 01:11:03

que sirve para la gestión de cámaras 01:11:05

pero en este caso me sirve también para 01:11:07

explicar el smooth-time y que lo hagáis 01:11:09

un poco de la manera tradicional. 01:11:11

Lo que vamos a hacer 01:11:13

es que la cámara 01:11:15

va a tener un script que va a ir diciendo en todo momento 01:11:17

cuánto 01:11:19

offset, es decir, cuánto decalaje 01:11:21

cuánta... 01:11:23

no sé cómo decir esta palabra, decalaje 01:11:25

cuánta 01:11:27

distancia relativa va a tener 01:11:29

con respecto al objeto que está siguiendo en este caso 01:11:31

que va a ser la nave, para que se mueva con la nave. 01:11:33

Lo primero 01:11:35

que vamos a hacer, me voy a hacer aquí un script 01:11:37

nuevo para las coordenadas 01:11:39

de la cámara que se vayan calculando 01:11:41

en relación a 01:11:43

la posición. 01:11:45

Que se vayan calculando en relación a lo que nosotros le digamos. 01:11:47

¡Ojo! 01:11:49

¿Recordáis cómo se declaraba un script? 01:11:51

Y que como la cámara 01:11:53

y la posición de la cámara va a ser la que se va a ir 01:11:55

actualizando para que siga 01:11:57

a la nave, pues hay 01:11:59

que incorporarla como componente. 01:12:01

¿Vale? Importante. 01:12:03

Entonces, una vez estamos aquí, voy a 01:12:05

abrir... 01:12:07

No me está abriendo 01:12:09

esto una cosa... 01:12:11

Aquí tengo una cosita... 01:12:15

Vale. 01:12:17

Voy a este código 01:12:19

y lo dejo aquí. Tengo aquí el script 01:12:21

que como antes hemos habido cosas 01:12:23

lo dejo por aquí. 01:12:25

Vale, ya está. 01:12:27

Estoy colocándome... 01:12:33

Tengo otra pantalla por aquí. 01:12:35

Vale. 01:12:37

Vale. 01:12:39

Entonces, tenemos aquí este script 01:12:41

de Camera Position preparado 01:12:43

para decirle cómo tiene que actuar 01:12:45

la cámara. ¿Vale? 01:12:47

Y lo que vamos a hacer es 01:12:49

que la posición de la cámara 01:12:51

coja la de 01:12:53

otro elemento de la escena. 01:12:55

Entonces, igual que hacíamos con la instancia, 01:12:57

lo que vamos a decirle es 01:12:59

¡Ojo! Yo quiero 01:13:01

que la posición de la cámara 01:13:03

la coja de otro elemento. 01:13:05

¿Cómo hacíamos 01:13:07

en la primera práctica 01:13:09

que otro elemento nos diera sus propiedades? 01:13:11

Pues lo que hacíamos, por ejemplo, 01:13:13

en este momento del curso, era decirle 01:13:15

que 01:13:17

en una variable de tipo Transform 01:13:19

o en una variable de tipo GameObject, 01:13:21

ahora mismo como lo que quiero son las coordenadas de otro objeto, 01:13:23

voy a ponerle Transform 01:13:25

para que coja lo relativo a su componente Transform. 01:13:27

Voy a poner que coja... 01:13:29

Bueno, que tenga un Target 01:13:31

que va a ser la nave a la que va a seguir. 01:13:33

¿Vale? 01:13:35

Entonces, recordad que yo cuando pongo el Serialize Fill 01:13:37

ahora vais a ver que en esta cámara 01:13:39

hay un objeto 01:13:41

que está esperando un objeto 01:13:43

que le pasemos algo para que coja 01:13:45

las coordenadas. Aquí es donde 01:13:47

el otro día en la práctica 1 01:13:49

os dije que 01:13:51

el padre de todo el prefab 01:13:53

fuera coordenadas puras, 0, 0, 01:13:55

porque así va a ser bastante más fácil 01:13:57

estar en todo momento identificando 01:13:59

los puntos de referencia 01:14:01

desde los que tiene que 01:14:03

gestionarse todo, por ejemplo, 01:14:05

este seguimiento de cámara. 01:14:07

Como lo que va a seguir es a esta nave, 01:14:09

la arrastro aquí. 01:14:11

Ahora hemos guardado en una variable llamada 01:14:13

Target 01:14:15

las coordenadas 01:14:17

del objeto. 01:14:19

Entonces, 01:14:21

si yo tengo, y voy a decir 01:14:25

que este prefab, por ejemplo, 01:14:27

tenga... 01:14:29

Voy a hacer 01:14:31

básicamente... 01:14:33

Si hago todo de cero, 01:14:35

tardo mucho. Voy a ver cómo lo puedo simplificar. 01:14:37

En esta cámara 01:14:39

lo que vamos a decirle es que 01:14:41

por defecto coja 01:14:43

que la posición de la cámara, 01:14:45

es decir, su Transform Position 01:14:47

sea igual al 01:14:51

Target 01:14:53

punto Position. 01:14:55

Es decir, 01:14:57

que de este Target coja su posición. 01:15:01

¿Esto qué significa? 01:15:03

Guardo que cuando yo 01:15:05

arranque el juego, porque lo he puesto 01:15:07

en el Start básicamente, 01:15:09

cuando se inicialice 01:15:11

este script que está 01:15:13

incorporando a la cámara, aunque aquí ponga 01:15:15

"-17 en la cámara", 01:15:17

vais a ver que al arrancar el juego 01:15:19

lo que hace es ponerse... De hecho, se ve este 01:15:21

círculo que es justo el morro de la cámara. 01:15:23

Se ha puesto en el 0,0 la cámara. 01:15:25

Ha cogido las propiedades 01:15:27

de la posición 01:15:29

de esa nave. 01:15:31

¿Esto qué significa? 01:15:33

Y aquí estaba haciendo algo que no 01:15:35

estaba funcionando, pero no sé muy bien por qué. 01:15:37

¿Qué significa? Que si esto 01:15:39

lo ponemos en el Update, que en cada momento 01:15:41

está refrescando 01:15:43

la posición 01:15:45

en relación a la del Target, 01:15:47

la posición del propio objeto 01:15:49

que lo tiene, que en este caso es la cámara, 01:15:51

estará en todo momento, cada fotograma 01:15:53

mirando dónde está la posición 01:15:55

del Target. 01:15:57

Esto es un primer paso para entender 01:15:59

que si yo 01:16:01

tengo aquí la nave, 01:16:03

ahora lo que pasa es que, como lo he creado en una escena nueva, 01:16:05

no tengo las interacciones de los inputs. 01:16:07

Pero si yo empiezo a subir 01:16:09

la nave, 01:16:11

a ver, perdonad que no estoy 01:16:13

moviendo el prefab, cuando yo vaya moviendo 01:16:15

esa nave, 01:16:17

como la cámara está actualizando 01:16:19

en todo momento, 01:16:21

no hay muchos puntos de referencia, pero como está actualizando 01:16:23

la posición, 01:16:25

la cámara va con ello. 01:16:27

Ahora la altura es de 18. 01:16:29

¿Por qué? Porque es la que tiene 01:16:31

esta nave prefab. Cuando yo subo 01:16:33

27,3, la nave ha heredado 01:16:35

este 27,3. 01:16:37

Hemos hecho por código ahora mismo 01:16:39

lo mismo que habíamos hecho antes de emparentar 01:16:41

en jerarquía, de hacer hijo 01:16:43

un elemento de otro. 01:16:45

Básicamente estamos diciendo que la posición 01:16:47

de este objeto esté todo el rato 01:16:49

igualándose a la posición del Target. 01:16:51

El problema es que, 01:16:53

claro, se está metiendo 01:16:55

en el 0,0 01:16:57

de la cámara, que es este eje, 01:16:59

es este punto que hay aquí, 01:17:01

donde coincide el gizmo. 01:17:03

Y claro, estamos dentro de la cámara. 01:17:07

Lo que vamos a querer es 01:17:09

que esta posición, 01:17:11

y recordamos que 01:17:13

las posiciones son un vector 3, 01:17:15

es decir, tiene tres ejes, 01:17:17

realmente lo que está 01:17:19

haciendo es 01:17:21

tener 01:17:23

un vector 01:17:25

que va a tener una desviación 01:17:27

en alguno de los 01:17:29

ejes. 01:17:31

¿Esto qué significa? 01:17:33

Como hemos dicho antes, esto es un vector 3 01:17:35

que está refiriéndose 01:17:37

a otro vector 3 de tres dimensiones. 01:17:39

Si lo que queremos es 01:17:41

que la posición del objeto 01:17:43

se esté recalculando 01:17:45

en referencia 01:17:47

a la del Target, 01:17:49

también podemos decir que 01:17:51

en todo momento esté recalculando 01:17:53

ese vector 3 que tiene, 01:17:55

como 01:17:57

se explica en la lección, tres ejes. 01:17:59

Pueden incluso usarse para dos, 01:18:01

la tercera dimensión no es obligatoria. 01:18:03

Pero tiene tres ejes, que son la X, 01:18:05

la Y y la Z. Entonces, si decimos 01:18:07

que coja el eje X 01:18:09

de esta posición, vamos diciéndole 01:18:11

cuáles son 01:18:13

cada uno de los ejes del 01:18:15

vector 3 en relación a los del Target, 01:18:17

si hacemos esto, 01:18:19

que es muy enrevesado, 01:18:21

pero ahora veremos el porqué, 01:18:23

y es también lo que ha planteado vuestro compañero, 01:18:25

la solución. Si ponemos esto, 01:18:27

es exactamente lo mismo, equivalente 01:18:29

a lo que habíamos hecho antes. ¿Por qué? 01:18:31

Lo copio. 01:18:33

Lo que hemos hecho 01:18:35

aquí es descomponer 01:18:37

el Transform Position 01:18:39

del Target en sus tres dimensiones. 01:18:41

Ahora mismo, 01:18:43

esto y esto es lo mismo. 01:18:45

Solo que estamos diciendo que haya un vector 3 01:18:47

que rellene cada uno 01:18:49

de las tres posiciones en relación 01:18:51

a las tres posiciones que tiene este Position 01:18:53

en su Transform. 01:18:55

Esto lo que nos permite 01:18:57

es que en cada uno de los ejes 01:18:59

podamos decirle menos 10, 01:19:01

o más 45, 01:19:03

ahora lo estoy haciendo al azar, 01:19:05

o más 80, 01:19:07

yo qué sé. 01:19:09

Ahora, en todo momento, va a estar 01:19:11

recalculando la posición, 01:19:13

pero luego nosotros le estamos 01:19:15

diciendo que aparte haya un poco 01:19:17

de decalaje o se esté orientando 01:19:19

hacia otro punto. Es decir, 01:19:21

que si en X 01:19:23

la nave está en 10, 01:19:25

la cámara se va a poner 01:19:27

en 0 en el eje X. 01:19:29

O si está en 20, se va a poner en 10. 01:19:31

Hay un cierto decalaje. 01:19:33

Cuando le demos al Play, vais a ver 01:19:35

que ya no se ve que está dentro 01:19:37

del objeto, sino que la cámara 01:19:39

se ha puesto por delante 01:19:41

porque en Z le hemos dado 01:19:43

un valor positivo y además bastante amplio. 01:19:45

Esto lo que nos 01:19:47

permite es 01:19:49

que un poco 01:19:51

de manera consciente 01:19:53

podamos dar 01:19:55

este offset, esta distancia 01:19:57

que hay entre 01:19:59

el objeto que estamos 01:20:01

siguiendo con la cámara y la posición 01:20:03

de la cámara. ¿Cómo podemos 01:20:05

variar 01:20:07

esto? Por ejemplo, lo que podemos 01:20:09

hacer es traducir estos 01:20:11

decalajes que hemos metido aquí a mano. Igual 01:20:13

que os he dicho antes, 01:20:15

en vez de poner un número concreto 01:20:17

podemos poner un límite que así siempre podemos 01:20:19

estar aludiendo 01:20:21

a ese objeto en su variable. 01:20:23

Y además también nos permite incluso 01:20:25

serializarlo, que ahora vamos a ver 01:20:27

por qué. Entonces, podemos 01:20:29

generar floats 01:20:31

que sustituyan a estos 01:20:33

valores que tenemos aquí. Y va a haber, por ejemplo, 01:20:35

el offset 01:20:37

en X. 01:20:39

Pues ahí se queda. Luego vamos a hacer 01:20:41

otro que sea el offset 01:20:43

en Y. 01:20:45

Y luego el offset 01:20:47

en Z. 01:20:49

Float offset 01:20:51

en Z. 01:20:53

Y esto lo que podemos hacer es sustituirlo aquí 01:20:55

por cada uno de los offsets. 01:20:57

Es verdad que en este 01:20:59

caso en concreto, 01:21:01

lo voy a poner en positivo, 01:21:03

porque si no lo que haremos es poner en negativo 01:21:05

el valor de la variable, 01:21:07

vamos a ir poniendo 01:21:09

cada uno de los 01:21:11

de los decalajes. 01:21:15

Ahora mismo, 01:21:17

como ya os he comentado en otros momentos, 01:21:19

como no hemos dado ningún valor, 01:21:21

todo vale en cero. Por tanto, ahora mismo 01:21:23

está todo en su posición. 01:21:25

No hay ningún 01:21:27

tipo de decalaje. Pero aquí sí que 01:21:29

podemos decir, ojo, yo quiero 01:21:31

que 01:21:33

la cámara esté 01:21:35

40 01:21:39

unidades 01:21:41

por delante. 01:21:43

Porque al darle positivo, vamos a ver que cuando 01:21:45

yo le dé al play, la cámara 01:21:47

si la selecciono, está por 01:21:49

delante. Por eso no se ve la nave. 01:21:51

O que esté 01:21:59

40 por detrás, que esto es lo que nos puede 01:22:01

interesar, que pase lo que pase en el juego, 01:22:03

la cámara siempre esté por detrás, 01:22:05

apuntando hacia esa nave. 01:22:07

Y ahora vais a ver que la nave se ve ahí, 01:22:09

40 por detrás. 01:22:11

Nos puede interesar, y por eso 01:22:13

sucede esto, que aquí empecemos 01:22:15

a trastear mientras está en reproducción, 01:22:17

que es lo que comenté de tintar de rojo la pantalla 01:22:19

para saber cuándo ocurre esto, 01:22:21

que podemos ir variando 01:22:23

las posiciones 01:22:25

de los 01:22:27

elementos. 01:22:29

Aquí, aunque arrastra a los lados, 01:22:31

no me deja cambiarlo, porque el script, aunque yo 01:22:33

lo cambie, constantemente en el 01:22:35

update está 01:22:37

recalculando la posición. 01:22:39

Entonces no me está dejando 01:22:41

cambiar este valor. Pero lo que sí 01:22:43

que podemos hacer es 01:22:45

que este valor lo hagamos 01:22:47

serializado o público, 01:22:49

el de Z que es ahora mismo el que más nos interesa. 01:22:51

Y en vez 01:22:53

de meter aquí el valor 01:22:55

por defecto, lo hagamos 01:22:57

desde 01:22:59

este 01:23:03

este 01:23:05

campo editable. 01:23:07

¿Eso qué significa? Que mientras 01:23:09

yo estoy en play, puedo ir testeando 01:23:11

a qué altura podemos 01:23:13

dejar la cámara en vivo. 01:23:15

Y cuando le decimos 01:23:17

"-9", cuando dejemos de dar al 01:23:19

play, se ha movido. Pero aquí ya 01:23:21

sabemos que es "-9", porque lo hemos memorizado. 01:23:23

Podemos hacer lo mismo 01:23:25

por ejemplo en Y. 01:23:27

Yo quiero que este Y esté serializado. 01:23:29

Porque la X 01:23:31

es verdad que no queremos que se vaya hacia los lados. 01:23:33

De hecho, se podría 01:23:35

hasta borrar, porque no nos interesa 01:23:37

que haya decalaje en X. 01:23:39

Queremos que esté un poquito por detrás 01:23:41

y quizá un poquito por arriba 01:23:43

para angular la cámara. 01:23:45

Entonces, si ahora 01:23:47

le decimos que el offset sea de 01:23:49

vamos a dar al play 01:23:53

y decimos el offset 01:23:55

queremos que sea de 01:23:57

esto esté a "-12", 01:23:59

y el Y 01:24:01

esté a 3. 01:24:03

Bueno, o a 01:24:05

1,5. 01:24:07

Pues nada, lo ponemos aquí. 01:24:09

1,5 01:24:11

y "-12", creo que hemos dicho. 01:24:13

Ahora ya, según arranca el juego, 01:24:15

se pone en esa ubicación. 01:24:17

Por ejemplo, también podemos rotar la cámara 01:24:19

para que tenga un poquito de angulación. 01:24:21

La rotación 01:24:23

podríamos hacer un poco lo mismo 01:24:25

de la cámara con respecto, 01:24:27

pero en realidad lo que podemos hacer en cualquier momento 01:24:29

como tenemos este decalaje, 01:24:31

la nave cuando se vaya moviendo 01:24:33

se mueve 01:24:35

con ese 01:24:37

offset 01:24:39

y va a estar siempre por detrás 01:24:41

moviéndose con ese offset. 01:24:43

Podemos ir ajustando aquí con las variables. 01:24:45

¿Qué es lo que sucede? 01:24:47

Que ahora, y voy a 01:24:49

poner muy rápidamente... 01:24:51

Voy a reciclar el script 01:24:53

que nos pasó 01:24:55

Francisco Javier, 01:24:57

que ya lo habíamos... Bueno, no sé en qué estado ha quedado. 01:24:59

A ver, me meto un 01:25:01

segundo, porque con todo esto de la rotación 01:25:03

no sé si ha quedado 01:25:05

del todo correcto. 01:25:07

A ver... 01:25:09

Bueno, esto lo dejo así. 01:25:11

Y aquí, bueno, voy a poner... 01:25:13

Voy a borrar todo lo que 01:25:15

no conseguí hacer del todo correctamente. 01:25:17

Ni del todo, ni ninguna, 01:25:19

porque se ha quedado a medio escribir. 01:25:21

Y pongo 01:25:23

el método 01:25:25

que habíamos visto de los 01:25:27

inputs. 01:25:29

Si esto lo aplico ahora a la nave 01:25:31

que acabo de meter, Francisco Javier, 01:25:33

lo meto en la nave prefab, 01:25:35

ya volveré a tener 01:25:37

una nave con la que 01:25:39

puedo moverme. 01:25:41

Falta algo, que es 01:25:43

que hay que darle una velocidad, porque así 01:25:45

lo tiene configurado, y una rotación. 01:25:47

Porque tiene dos variables 01:25:49

serializadas para eso. 01:25:51

Ya debería ir... Vale. 01:25:53

Ya si os fijáis, cuando paso 01:25:55

por abajo sobre todo, porque no hay límites 01:25:57

que corten el movimiento, 01:25:59

que es otra de las cosas que hay que hacer. 01:26:01

Tengo la nave que se va moviendo. 01:26:03

Ya lo tengo 01:26:05

configurado con dos controles independientes. 01:26:07

Faltaría ir generando 01:26:09

los obstáculos, que es lo que va a dar la perspectiva 01:26:11

de que cuando se van acercando 01:26:13

los pivotes, parece que 01:26:15

la nave está avanzando, 01:26:17

pero en realidad es un trampantojo. 01:26:19

Hacemos que los obstáculos 01:26:21

sean los que se van acercando. 01:26:23

Vale. Entonces... 01:26:25

Rotación... 01:26:27

Lo voy a poner en 100. 01:26:29

Mientras estamos aquí, podemos ir probando 01:26:31

este offset y ir dando valores 01:26:33

para que se ponga en el 01:26:35

punto que 01:26:37

nos interese. Lo mismo. 01:26:39

Mientras estamos en reproducción, lo malo es 01:26:41

que luego habrá que apuntarse los números, aunque sea 01:26:43

en la cabeza, para saber 01:26:45

dónde está. A ver... 01:26:47

En X y lo angulo. 01:26:49

Con esto vamos definiendo 01:26:51

ese offset de manera automática. 01:26:53

Y ya la nave, cuando la muevo, 01:26:55

se va 01:26:57

a ir moviendo en base a eso. 01:26:59

¿Sí? Hasta aquí 01:27:01

me vais siguiendo más o menos. 01:27:03

Hace mucho que no os leo. 01:27:05

Vale. 01:27:07

Sí. Vale. 01:27:09

¿Qué es lo que ocurre? 01:27:11

Y lo que pedía un poco 01:27:13

en el enunciado. 01:27:15

Que es 01:27:17

que a ver si conseguíamos 01:27:19

que este movimiento de la cámara 01:27:21

estuviera suavizado. Es decir, 01:27:23

cuando jugáis a un juego, muchas veces 01:27:25

lo que sucede es que se va moviendo el personaje, 01:27:27

la nave en este caso, 01:27:29

y la cámara no va exactamente 01:27:31

con el movimiento 01:27:33

de ese personaje. 01:27:35

Sino que tarda un poco en reaccionar 01:27:37

para que el movimiento sea un poco más suave. 01:27:39

O si tiembla un poco, pues que 01:27:41

dé tiempo a corregirlo. 01:27:43

Y para ese tipo de funciones 01:27:45

se puede usar el 01:27:47

Smooth Damp, que es 01:27:49

lo que se ve al final del tema 2. 01:27:51

Sobre todo me sirve para 01:27:53

que veamos una forma 01:27:55

de pensar diferentes las variables 01:27:57

y el uso de la Smooth Damp. 01:27:59

Porque esto es verdad que de primeras es 01:28:01

un poco complejo. 01:28:03

Luego no lo es tanto 01:28:05

cuando se entiende, pero sí que es verdad que cada vez 01:28:07

que lo quieres hacer, tienes que refrescar cómo se hace. 01:28:09

Entonces, aunque en el tema 01:28:11

se pone algún ejemplo de cómo se 01:28:13

emplea, 01:28:15

para que sepáis de qué hablo 01:28:17

por si acaso no lo tenéis muy ubicado, 01:28:19

me refiero a esto último 01:28:21

de lo que se habla en el tema 2. 01:28:23

En contenido, 01:28:25

en movimiento suavizado, 01:28:27

aquí por ejemplo se habla del Lerp, 01:28:29

y en este caso del Smooth Damp. 01:28:31

Aquí un poco ya se ve 01:28:33

cómo se aplicaría un ejemplo. 01:28:35

Pero vamos a hacerlo 01:28:37

en base a este ejemplo. 01:28:39

Estos son los scripts 01:28:43

y tenemos el de la 01:28:45

cámara que había generado durante la 01:28:47

tutoría. Aquí está. Lo vuelvo a poner. 01:28:49

Ahora mismo, la cámara 01:28:55

en todo momento está yendo 01:28:57

a donde esté el objeto que sigue 01:28:59

con este offset que estamos indicando aquí. 01:29:01

¿Más o menos me seguís? 01:29:05

¿Qué es lo que he declarado aquí? ¿Este vector 3? 01:29:07

Una cosa que se 01:29:11

habla en el tema es que, por si acaso, 01:29:13

un vector 3 01:29:15

cuando se declara... 01:29:17

Lo estoy declarando mal y esto va a dar fallo. 01:29:19

Pero cuando tenemos un vector 3 01:29:21

que se descompone las tres dimensiones... 01:29:23

Bueno, aquí me ha escrito lo que quería. 01:29:25

X, Y y Z. 01:29:27

Estos deberían ser valores. 01:29:29

Tú tienes un valor 01:29:31

de cada uno de esos 01:29:33

vectores que puede ser una variable. 01:29:35

Como en este caso es cada uno de los ejes 01:29:37

que está cogiendo el valor. 01:29:39

Y luego aquí podemos operar. 01:29:41

Podemos hacer que ese primer valor sea por 2. 01:29:43

Y este entre 01:29:45

2 también. 01:29:47

Y esto más 7. 01:29:49

Podemos hacer operaciones con cada uno de los ejes. 01:29:51

Incluso se pueden sumar dos 01:29:53

vectores. 01:29:55

Esto es importante. 01:29:57

Y el vector 3 01:30:03

es un tipo de variable que podemos tener. 01:30:05

Si tenemos un vector 3 01:30:07

que se llama... 01:30:09

Igual que hacíamos con las sumas 01:30:11

en las primeras clases 01:30:13

que hacía una variable 01:30:15

que era número 1 y número 2 01:30:17

y luego lo sumaba y daba un resultado 01:30:19

que se podía hacer 01:30:21

cuentas 01:30:23

con esos datos. 01:30:25

También se pueden hacer 01:30:27

cuentas y multiplicaciones con los vectores. 01:30:29

Si yo hago un vector 3 01:30:31

que lo primero es vector 1 01:30:33

y luego 01:30:35

un vector 3 01:30:37

que es vector B 01:30:39

lo voy a poner B y A 01:30:41

porque así no lo confundimos 01:30:43

con otros números. 01:30:45

Luego en el start 01:30:47

lo que tendremos que decirle 01:30:49

es cuánto vale cada uno 01:30:51

porque ahora este valdrá 0, 0, 0 01:30:53

y este 0, 0, 0. 01:30:55

Si vector A 01:30:57

le decimos que es igual a 01:30:59

y ojo, cada vez 01:31:01

que vayamos a introducir 01:31:03

valores de un vector 01:31:05

hay que poner esto de new vector 01:31:07

y le decimos que este vale 2 01:31:09

en su dimensión 01:31:13

primera o en su eje X. 01:31:15

Este 4 me lo estoy inventando 01:31:17

y esto 6. 01:31:19

Luego tenemos un vector B 01:31:21

que es igual a 01:31:25

new vector 3 01:31:27

7, 8 01:31:33

y 0. 01:31:35

Lo que se podrá hacer 01:31:37

será 01:31:39

otra variable 01:31:41

o mostrar en algún punto 01:31:43

el valor de 01:31:45

una suma o una resta. 01:31:47

Voy a hacer 01:31:49

de modo global otro vector 3 01:31:51

que es resultado 01:31:53

operación vectores 01:31:55

y aquí es donde 01:31:57

vamos a ir diciendo 01:31:59

qué queremos que ocurra con los datos 01:32:01

de esos vectores. Esto me sirve 01:32:03

para que veáis qué estoy haciendo aquí 01:32:05

en cada uno de los ejes, 01:32:07

qué se puede hacer de operaciones 01:32:09

cuando usamos vectores. 01:32:11

Si tenemos 01:32:13

esta variable y le decimos 01:32:15

que sea igual a 01:32:17

vector A 01:32:19

más 01:32:21

vector B 01:32:23

lo que está haciendo es 01:32:25

operar con matrices. 01:32:27

¿Eso qué significa? 01:32:29

Que la dimensión 1 01:32:31

se suma con la dimensión 1, 01:32:33

con el primer índice de cada uno. 01:32:35

Esta se sumará con la segunda 01:32:37

y esta con su correspondiente. 01:32:39

Es decir, se hacen operaciones 01:32:41

digamos cruzadas 01:32:43

por cada una de las posiciones. 01:32:45

¿Eso qué significa? Que si yo en un debug log 01:32:47

ahora mismo 01:32:49

le digo que me enseñe 01:32:51

el resultado 01:32:53

de la operación 01:32:55

creo que no tengo 01:32:57

otros debug logs, aunque 01:32:59

en el... A ver, un segundo, 01:33:01

perdonad, porque en el 01:33:03

de Francisco Javier había un debug log 01:33:05

que si no, no nos va a dejar ver bien 01:33:07

qué pasa. 01:33:09

¿Dónde está? ¿Por qué no se me abre? 01:33:11

¿Estará por aquí abierto? 01:33:13

Vale, en Francisco Javier, 01:33:15

en el otro. Tenía aquí un debug log 01:33:17

que enseñaba en todo momento 01:33:19

el desplazamiento de X, que ya no da igual. 01:33:21

Vuelvo aquí. Si hago un debug log 01:33:23

del resultado de operación vectores, 01:33:25

cuando yo le dé al play, 01:33:27

vais a ver que lo que me está devolviendo es 01:33:31

tres dimensiones, 01:33:33

un vector 3, 01:33:35

que vale 9, 12 y 6. 01:33:37

Y si os fijáis, vale 9, 12 y 6 01:33:39

porque lo que ha hecho 01:33:41

es sumar 2 más 7, 9, 01:33:43

4 más 8, 12, 01:33:45

y 6 más 0, 6. 01:33:47

¿Veis que entre vectores 01:33:49

se puede ir operando? 01:33:51

Se pueden ir haciendo estas operaciones, o incluso 01:33:53

digo, no, esto es una resta. 01:33:55

El resultado ahora va a ser 01:33:57

menos 5, menos 4 01:33:59

y menos 0, 6. 01:34:01

Menos 5, menos 4, 6. 01:34:03

He guardado, 01:34:05

cuando le dé aquí al play, 01:34:07

menos 5, menos 4, 6. 01:34:09

Cuando vayamos usando 01:34:11

coordenadas, 01:34:13

o por ejemplo aquí que hemos cogido el 01:34:15

transporte de la nave, 01:34:17

lo que estamos haciendo es usar tres valores 01:34:19

guardados, empaquetados en uno, 01:34:21

y lo vamos 01:34:23

empleando. Por eso, a diferencia 01:34:25

de lo que pasa con un float, que es 01:34:27

solo un número, 01:34:29

además te lo pone de un color azul diferente 01:34:31

al de vector 3, que es otro tipo de variable, 01:34:33

si nos ponemos encima los vectores 01:34:35

3, al guardar en sí mismo 01:34:37

varios valores diferentes, 01:34:39

es una variable 01:34:41

multivalor, y por eso veréis que 01:34:43

se llama strut, es una estructura de diferentes 01:34:45

valores. Eso es lo que 01:34:47

implica que cada vez que queramos 01:34:49

definir los valores 01:34:51

de un vector 3, 01:34:53

hay que declarar una nueva estructura. 01:34:55

Es como una explicación, 01:34:57

quizá un informático me diga que no es 01:34:59

la ortodoxa, pero 01:35:01

la realidad es esa, que cuando queremos 01:35:03

asignar nuevos valores, 01:35:05

tenemos que hacer una nueva 01:35:07

instancia, 01:35:09

un nuevo vector 3 01:35:11

para que pueda 01:35:13

guardar varios valores 01:35:15

en sí mismo. 01:35:17

Entonces, lo que no se puede 01:35:19

hacer directamente, hay que usar otros 01:35:21

métodos, es hacer multiplicaciones 01:35:23

entre los valores de los vectores. 01:35:25

¿Veis que da fallo? Igual pasa 01:35:27

con las divisiones. 01:35:29

¿Vale? Entre dos valores 01:35:31

independientes, 4 entre 6, con dos 01:35:33

floats sí se podía. Esto ya lo 01:35:35

vimos, si no me equivoco. 01:35:37

Pero con vectores solo se pueden hacer 01:35:39

operaciones de suma o resta. 01:35:41

Lo que sí se puede hacer, para saber 01:35:43

qué limitaciones tiene, 01:35:45

es multiplicar todos los valores 01:35:47

de un 01:35:49

vector por 01:35:51

un número. En este caso, 01:35:53

vector A, es decir, estos tres valores 01:35:55

se multiplicarán por 2. 01:35:57

Si ahora vemos el resultado, 01:35:59

lo que va a valer es 4, 01:36:01

8 y 12. 01:36:03

Se puede hacer multiplicaciones 01:36:05

de vectores, por ejemplo aquí, por 2. 01:36:07

Y no hay ningún problema, 01:36:09

cogerá cada una de las tres dimensiones y lo multiplica 01:36:11

por 2. O incluso dividirlo 01:36:13

entre 2. Eso tampoco debería 01:36:15

dar problema. Lo que nos va a dejar es 01:36:17

multiplicar vectores 01:36:19

por sí mismo. Por ejemplo, aquí nos va 01:36:21

a dejar que hagamos esta multiplicación 01:36:23

entre este strut 01:36:25

que tenemos aquí y el strut de este vector 01:36:27

guardado en esta variable. 01:36:29

¿Vale? Para que 01:36:31

sepáis, limitaciones. 01:36:33

Sí que es verdad que se pueden hacer multiplicaciones 01:36:35

entre vectores. Bueno, 01:36:37

os enseño que va a dar 4, 8, 12. 01:36:39

Le doy al play 01:36:41

y vais a ver qué es. 4, 8, 12. 01:36:43

¿Vale? 01:36:45

Eso, que a veces 01:36:49

si queremos que todos los valores de un 01:36:51

vector se multipliquen 01:36:53

por algo o se dividan por algo, eso sí está permitido. 01:36:55

Lo que no se puede hacer de manera 01:36:57

directa es 01:36:59

hacer operaciones cruzadas 01:37:03

de multiplicación. Ahora 01:37:05

cedo la palabra, pero 01:37:07

sí que hay. A ver... 01:37:09

En vectores 01:37:11

hay un punto 01:37:13

que será en posicionar. 01:37:15

Estas cosas más o menos se... 01:37:17

A ver, espera... 01:37:19

A ver... 01:37:21

No me acuerdo exactamente en dónde era. 01:37:23

Vale, aquí. En el punto 01:37:25

2.3.1 habla de 01:37:27

métodos relacionados 01:37:29

o que operan con vectores. Y por ejemplo 01:37:31

hay uno que se llama escalar vectores. 01:37:33

Entonces pone, además de multiplicar 01:37:35

un vector por una cantidad, que es lo que acabamos de hacer, 01:37:37

lo que aumenta su longitud sin variar 01:37:39

su dirección. Es decir, si un vector 01:37:41

está orientándose hacia una 01:37:43

dirección, cuando lo multiplicamos 01:37:45

puede cambiar cuánto vale toda la dirección, 01:37:47

el vector en sí, 01:37:49

pero no cambia la dirección 01:37:51

relativa, porque como siempre va a ser 01:37:53

todos los números por 01:37:55

igual en una proporción, 01:37:57

no cambia esa dirección. 01:37:59

Pero se puede usar este método 01:38:01

para hacer multiplicación de vectores 01:38:03

usando este scale. 01:38:05

Que si nos metemos, pues 01:38:07

explica un poco qué. Si hacemos un... 01:38:09

Vamos, muy... 01:38:11

Lo hago aquí rápidamente. 01:38:13

Si yo pongo la operación scale... 01:38:15

A ver... 01:38:17

Un segundín... 01:38:19

Ah, vale, sí. 01:38:21

Hay que decir que es una operación de 01:38:23

la clase Vector3. 01:38:25

Yo digo que sea scale. 01:38:27

Es un poco más enrevesado. Y aquí sí 01:38:29

que meto los dos vectores 01:38:31

que quiero 01:38:33

que se multipliquen, ahora no va a dar 01:38:35

fallo y vais a ver que va a valer 01:38:37

14, 01:38:39

32 01:38:41

y 0. 01:38:43

14, 32 y 0. 01:38:45

Si guardo y muestro 01:38:47

el editor... 01:38:49

14, 01:38:51

32 y 0, exactamente. 01:38:53

Esto lo explico porque cuando 01:38:55

vayáis intentando ir 01:38:57

sacando resultados 01:39:01

y en algún momento lo que queréis es 01:39:03

sumar o restar valores 01:39:05

como hemos hecho aquí, que sepáis 01:39:07

qué limitaciones tienen los vectores. 01:39:09

Por eso lo cuento un poco. 01:39:11

¿Alguien quería hablar? 01:39:13

Sí, una pregunta. 01:39:15

¿Multiplicar un vector por un 01:39:17

número, si lo haces con 01:39:19

una variable entre un rango, por ejemplo, 01:39:21

en el caso de un videojuego, lo puedes poner 01:39:23

para que en el update 01:39:25

los enemigos se te posicionen en cualquier 01:39:27

posición diferente y te vaya cambiando? 01:39:29

Sí, claro. 01:39:31

Por ejemplo, una cosa 01:39:33

que no sé si ya has hecho 01:39:35

es que en el enunciado 01:39:37

se habla de que para ir 01:39:39

aleatorizando la posición en X 01:39:41

en la que salen los pivotes se usa 01:39:43

una aleatoria, un random 01:39:45

range. Tú si 01:39:47

básicamente 01:39:49

digamos, a ver... 01:39:51

Tienes aquí 01:39:53

cada uno de estos valores 01:39:57

y lo multiplicas por un valor que has 01:39:59

calculado previamente con un random range, 01:40:01

tú al multiplicarlo por ese valor se va a ir 01:40:03

ubicando en distintos sitios. 01:40:05

No sé si me estoy explicando. 01:40:07

Sí, eso me refería. 01:40:09

Entonces, es básicamente 01:40:11

lo que deberíais hacer en la tarea 01:40:13

con los pivotes. 01:40:15

Porque... 01:40:17

Mira, muy fácil. 01:40:19

Si yo declaro 01:40:21

una variable que es... 01:40:23

A ver... 01:40:25

Lo que pasa 01:40:29

es lo de multiplicarlo por un número, 01:40:31

ahora te digo cómo lo haría yo, 01:40:33

multiplicarlo por un número es lo que he dicho, 01:40:35

que te lo podrá poner más o menos lejos, 01:40:37

pero siempre va a ser en la misma 01:40:39

línea. No sé si me explico, porque si 01:40:41

todo lo multiplicas por dos, 01:40:43

al ser 01:40:45

siempre proporcionales 01:40:47

cada una de las multiplicaciones en cada uno de sus ejes, 01:40:49

al final, 01:40:51

tú lo que consigues es que a lo mejor 01:40:53

en vez de... Imagínate 01:40:55

que el punto de referencia es donde está la nave, el 00, 01:40:57

y hemos puesto aquí el punto, 01:40:59

el primer punto. Si esto lo multiplicamos 01:41:01

por dos, se va a este punto, 01:41:03

pero no va a cambiar aquí. 01:41:05

Se va a ir moviendo 01:41:07

en esta línea. 01:41:09

Daniel, perdona, es que me tengo que ir 01:41:11

porque estaba con el móvil 01:41:13

y es que se me está acabando la batería ya. 01:41:15

Pues nada, bueno, 01:41:17

acabo ya porque eres el último que queda, 01:41:19

pero 01:41:21

eso, sí que se podrían hacer ese tipo de 01:41:23

operaciones. 01:41:25

Bueno, muchas gracias. 01:41:27

Voy a explicar y lo dejo grabado lo del smooth 01:41:29

program y ya estaría. 01:41:31

Muchas gracias. 01:41:33

Bueno, continúo. 01:41:37

Una vez 01:41:39

hemos hablado de las operaciones que permiten 01:41:41

estos vectores, que esto ha sido un poco 01:41:43

por funciones 01:41:45

explicativas, 01:41:47

un poco para que sepáis 01:41:49

qué operaciones permiten estos 01:41:51

vectores, 01:41:53

los struts, etc. 01:41:55

Para conseguir que 01:41:57

la cámara o un objeto 01:41:59

se mueva con cierta 01:42:01

suavidad o que 01:42:03

haya un momento 01:42:05

en el que no es un movimiento directo 01:42:07

sino que hay cierto decalaje, 01:42:09

podemos usar lo que he comentado antes del 01:42:11

smooth damp. Para eso 01:42:13

lo que vamos a hacer 01:42:15

es, 01:42:17

ya que lo hemos hecho, 01:42:19

definir una variable 01:42:21

vector3, que por ejemplo 01:42:23

sea la posición del 01:42:25

target, donde está ubicado el target 01:42:27

en todo momento. 01:42:29

Cuando 01:42:31

arranquemos el 01:42:33

juego, pues estamos 01:42:35

cogiendo una posición del target, pero 01:42:37

con esta variable lo que vamos a decir 01:42:39

es dónde se está 01:42:41

moviendo en cada momento ese target. 01:42:43

Es decir, si 01:42:45

decimos 01:42:47

que donde queremos estar 01:42:49

es 01:42:51

donde 01:42:53

queremos ir yendo en cada momento 01:42:55

es esta X, 01:42:57

un poco lo que ya tenemos aquí. 01:42:59

Estos decalajes que tenemos aquí 01:43:01

ya asignados. 01:43:03

La posición que vamos a 01:43:05

querer ir al final, después 01:43:07

del movimiento, es esta posición que tenemos aquí. 01:43:09

Esta es la posición en la que queremos 01:43:11

acabar después de cada movimiento. 01:43:13

Es decir, que si la nave sube, 01:43:15

aquí se está calculando con el 01:43:17

decalaje y al final lo que queremos es que la cámara 01:43:19

termine estando aquí. Pero en ningún 01:43:21

momento le estamos diciendo que su posición 01:43:23

pasa a ser aquí. Simplemente estamos 01:43:25

guardando la posición de la nave 01:43:27

con el decalaje en esta variable. 01:43:29

Lo que vamos a hacer es 01:43:31

que posteriormente vamos a decir 01:43:33

que la posición de la cámara, que es la 01:43:35

que tiene este script, 01:43:37

sea 01:43:39

esta. 01:43:41

Si hiciéramos esto, lo que estamos haciendo 01:43:43

es exactamente lo mismo de antes, de decir 01:43:45

transform position es igual a esto. 01:43:47

Porque básicamente lo estamos 01:43:49

moviendo aquí. Lo que vamos a decir es 01:43:51

que esta posición 01:43:53

se haga 01:43:55

igual que hemos hecho antes con el 01:43:57

Vector3Scale, que lo 01:43:59

haga con un suavizado, con este 01:44:01

SmoothDamp. ¿Y cómo funciona el SmoothDamp? 01:44:03

Que lo podemos ver 01:44:05

como siempre 01:44:07

en el API, en los manuales 01:44:09

que tenemos. Si aquí ponemos 01:44:11

SmoothDamp, 01:44:13

nos va a dar información muy útil de cómo 01:44:15

se declara. Y esto es referido a una 01:44:17

posición, pero también puede ser a 01:44:19

números, que para eso habría que usar el matemático. 01:44:21

Un poco 01:44:23

la lógica de cada uno es el mismo. 01:44:25

Y si os fijáis, lo complicado que 01:44:27

tiene, que ahora lo 01:44:29

hacemos de una forma más amigable, 01:44:31

es que tiene bastantes argumentos. 01:44:33

Tiene un Vector3, 01:44:35

que es donde está 01:44:37

actualmente 01:44:39

el objeto, 01:44:41

y 01:44:43

un segundo Vector3, 01:44:45

que es hacia dónde debe 01:44:47

ir el objeto. 01:44:49

Aquí estamos diciendo que vaya de un sitio, 01:44:51

que es donde está ahora, a otro, que es el que tiene que ir. 01:44:53

Esos son los dos primeros 01:44:55

argumentos. Si yo 01:44:57

hablo paréntesis, 01:44:59

como suele pasar, y cuando estoy 01:45:01

declarando esto, 01:45:03

nos salen las sobrecargas, 01:45:05

vamos a recurrir al primero, que es el 01:45:07

que menos argumentos tiene. Nuevamente 01:45:09

tenemos un Vector3 de la posición 01:45:11

actual, 01:45:13

y un Vector3 de 01:45:15

a dónde quiero ir. Ahora seguimos con 01:45:17

estos dos, que son un poco más complejos. 01:45:19

Si aquí 01:45:21

lo que le decimos es que 01:45:23

coja el Transform Position, 01:45:25

es decir, cuando ponemos Transform 01:45:27

sin poner nada más, estamos 01:45:29

hablando del Transform del objeto que tiene. 01:45:31

Es decir, el Transform de la cámara. 01:45:33

Donde partes, 01:45:35

donde en cada momento esté 01:45:37

la cámara. 01:45:39

Incluso, yo que sé, 01:45:41

si lo queremos dejar aún más 01:45:43

claro, igual que tenemos aquí 01:45:45

un Vector3, que es la posición hacia la 01:45:47

que tiene que ir, esa posición 01:45:49

de destino, vamos a decir 01:45:51

otra que sea 01:45:53

la posición actual, CurrentPost, 01:45:55

por ejemplo. 01:45:57

Y vamos a decir, según empiece el juego, para que 01:45:59

no haya ningún problema, 01:46:01

que al 01:46:03

empezar el juego, 01:46:05

esta CurrentPost 01:46:07

sea igual a 01:46:09

TransformPosition. Es lo mismo 01:46:11

que antes. 01:46:13

En realidad, ahora, cuando empleemos 01:46:15

aquí 01:46:17

CurrentPost, 01:46:19

lo que estamos haciendo 01:46:21

es que estamos 01:46:23

remitiendo a la posición 01:46:25

en la que esté en ese momento la cámara. 01:46:27

Entonces, queremos 01:46:29

que de ese punto en el que empieza, 01:46:31

o en cada fotograma, cuando se vaya refrescando, 01:46:33

en el punto en el que va a ir guardándose 01:46:35

ese CurrentPost, que, ojo, 01:46:37

en algún momento tendremos que decir 01:46:39

cuándo se actualiza por la posición 01:46:41

de cada fotograma, porque si no, siempre va a estar 01:46:43

cogiendo la posición del comienzo, 01:46:45

del Start, en este caso. 01:46:47

Tenemos esa posición 01:46:49

en la que va estando en cada fotograma, 01:46:51

y luego 01:46:53

vamos a decirle que 01:46:55

tiene que ir a ese destino 01:46:57

que era el TargetPost. 01:46:59

Ahora mismo este 01:47:01

SmoothDAM sabe de dónde 01:47:03

está y a dónde tiene que ir. 01:47:05

Si 01:47:07

volvemos a los 01:47:09

cuatro, bueno, aquí me está 01:47:11

poniendo 01:47:13

los argumentos 01:47:15

del más largo, si usáramos todos, 01:47:17

pero si empezamos, tenemos 01:47:19

el actual, el Target, luego la velocidad 01:47:21

actual, es decir, 01:47:23

se puede hacer que ya haya una inercia 01:47:25

en ese 01:47:27

suavizado de movimiento. 01:47:29

Esto es más complejo 01:47:31

y tiene que ver además con 01:47:33

las físicas y con movimientos heredados. 01:47:35

Si os fijáis, tiene como una 01:47:37

referencia. Cuando pone aquí una palabra 01:47:39

delante del tipo de variable como referencia, 01:47:41

esto lo veremos también en los 01:47:43

Raycast, más adelante, 01:47:45

significa que hay que escribir esta palabra. 01:47:47

Si vamos al ejemplo, por ejemplo, 01:47:49

vais a ver que hay una posición de partida, 01:47:51

una posición de destino, 01:47:53

este es otro ejemplo de SmoothDAM, 01:47:55

y aquí hay una referencia de la 01:47:57

Velocity, que además es un vector cero. 01:47:59

Normalmente no vamos a querer que haya una 01:48:01

inercia ya en el movimiento porque si no, 01:48:03

la cámara en este caso estaría todo el rato 01:48:05

dando tirones intentando ir hacia un lado. 01:48:07

Por eso, aquí lo han igualado 01:48:09

a cero, un vector 3-0 que es 0-0-0 01:48:11

y no añade ningún tipo de velocidad. 01:48:13

Sé que no aporta mucho 01:48:15

esto, que parece que no aporta mucho, pero es 01:48:17

obligatorio para este método. Entonces, siempre 01:48:19

hay que contar con que hay que poner un ref 01:48:21

como tercer argumento, 01:48:23

y aquí meter, podríamos incluso 01:48:25

hacer directamente que sea un newVector3 01:48:27

0-0-0. 01:48:31

O lo que es 01:48:35

lo mismo, 01:48:37

aquí no lo está cogiendo bien, 01:48:39

newVector3, 01:48:41

porque la referencia no permite que sea 01:48:43

una que no se pase. 01:48:45

Y aquí este fallo 01:48:49

es porque, y vuelvo al 01:48:51

lector de fallos, 01:48:53

da fallo porque todavía no hemos terminado 01:48:55

de escribir esto. Un segundo, 01:48:57

que voy a terminar de... 01:48:59

Si pongo 5 aquí 01:49:01

y cierro, 01:49:03

da fallo. 01:49:05

La velocidad, 01:49:07

la referencia, 01:49:09

vector 3-0-0-0, 01:49:11

vector 3-0. 01:49:13

Un segundillo... 01:49:15

Da fallo también. 01:49:17

En la referencia, como bien dice, 01:49:19

pensaba que sí se podía, pero cosas que... 01:49:21

La referencia, 01:49:23

al final, necesita 01:49:25

referencia a una variable, entonces hay que 01:49:27

introducirla como una variable. 01:49:29

Lo que vamos a hacer es 01:49:31

que... 01:49:33

Un segundo... 01:49:35

Vamos a crear otro vector 01:49:37

3, 01:49:39

que nos va a servir para esa velocidad, 01:49:41

o esa velocity, 01:49:43

de referencia 01:49:45

de la inercia. 01:49:47

Y aquí es donde vamos a decir 01:49:49

que este velocity, ahora cuando lo 01:49:51

escriba no debería dar 01:49:53

conflicto. Como por defecto es 01:49:55

un vector 0-0-0, no va a 01:49:57

tener inercia heredada. Aquí sí que se 01:49:59

podría declarar en algún momento que 01:50:01

hubiera un new vector 01:50:03

3. ¿Veis que a veces donde colocamos 01:50:05

las cosas nos da 01:50:07

bastantes problemas? 01:50:09

Y aquí sí que, en principio, debería 01:50:11

funcionar sin problema. 01:50:13

Y ojo, esto es lo mismo 01:50:15

sin el new, cuando lo hacemos de este 01:50:17

modo. Esto es lo mismo que 01:50:19

escribir las formas simplificadas 01:50:21

que hay de... 01:50:23

como el vector 3 forward, etc. 01:50:25

Como ya está construido ese vector, no 01:50:27

hace falta hacer un new delante. 01:50:29

Ya son un 01:50:31

tipo de vector. 01:50:33

Y aquí pone, bueno, atajo para escribir vector 01:50:35

3-0-0-0. 01:50:37

Normalmente, a menos que 01:50:39

sepamos por qué queremos darle una 01:50:41

inercia, en esta referencia habrá que meter 01:50:43

una variable que valga 01:50:45

0-0-0. 01:50:47

Y luego el último valor 01:50:49

del smooth damp, 01:50:51

si volvemos aquí, 01:50:53

tenemos la current velocity de referencia, 01:50:55

la inercia, 01:50:57

el tiempo de suavizado. Y esto 01:50:59

es el momento clave 01:51:01

para definir 01:51:03

lo que estamos buscando en todo momento, que es 01:51:05

entre esta posición y esta, 01:51:07

este valor, pues es la inercia que estamos 01:51:09

obviando, cuánto tiempo tiene que 01:51:11

tardar. Aquí es donde le podemos decir 01:51:13

el tiempo que tarda entre ir 01:51:15

de la primera a la segunda posición. 01:51:17

Entonces, 01:51:19

como siempre, vamos a intentar ser 01:51:21

más elegantes y vamos a decir 01:51:23

que ese tiempo lo guardamos 01:51:25

en 01:51:27

una variable llamada tiempo suavizado 01:51:29

o smooth time, si lo sigo 01:51:31

escribiendo en inglés. 01:51:33

Y le digo, pues esto yo que sé que 01:51:35

sea un 0,3. Ahora vemos 01:51:37

qué valor. Lo podríamos serializar 01:51:39

para ir comprobando, como hemos hecho antes. 01:51:41

Pero si aquí yo pongo tiempo 01:51:43

suavizado, que remite a ese valor que 01:51:45

acabamos de hacer, ya estamos diciéndole 01:51:47

entre este valor y este cuánto tiempo 01:51:49

debería tardar. 01:51:51

Esto es ir probando valores y tendrá 01:51:53

un suavizado o menos. 01:51:55

Ahora vamos a ver. 01:51:57

¿Qué falta en este momento? 01:51:59

Pues que 01:52:01

el targetPos en cada 01:52:03

fotograma se está recalculando en base 01:52:05

a las posiciones. 01:52:07

Cuando llega aquí, el targetPosition 01:52:09

está cogiendo la posición 01:52:11

de este transform y lo está recalculando. 01:52:13

Pero si os fijáis, en ningún momento 01:52:15

se está actualizando 01:52:17

este currenPos, que al principio 01:52:19

en el primer fotograma coge la posición 01:52:21

donde esté la cámara, pero 01:52:23

aquí, claro, si siempre decimos 01:52:25

que hay que ir de esta posición de la cámara 01:52:27

a donde esté 01:52:29

el objeto que sigue, 01:52:31

pues siempre va a estar intentando partir 01:52:33

del mismo sitio. No, lo que hay que 01:52:35

hacer es decir 01:52:37

en cada fotograma también 01:52:39

que esta 01:52:41

posición actual, este 01:52:43

punto de partida, en cada cálculo 01:52:45

del Smooth Dam, 01:52:47

lo haga en relación a 01:52:49

en la posición que esté en cada 01:52:51

fotograma el objeto. Es decir, 01:52:53

que aquí hemos calculado 01:52:55

con el decalaje hacia dónde 01:52:57

tenemos que ir, en referencia al otro objeto 01:52:59

que estamos metiendo 01:53:01

por el editor, en este caso la nave, 01:53:03

y aquí 01:53:05

la posición del objeto va a ser la 01:53:07

que devuelva este Smooth Dam que está 01:53:09

circulando entre dónde está 01:53:11

el objeto originalmente y esta posición. 01:53:13

Pero claro, para que se vaya 01:53:15

variando esta posición, como ya he dicho, 01:53:17

en cada fotograma también habrá que decir 01:53:19

yo voy a partir 01:53:21

siempre de la posición en que esté en cada fotograma. 01:53:23

Por tanto, hay que 01:53:25

trasladar esta posición 01:53:27

actual y guardarla en la variable 01:53:29

para que cuando vuelva a hacer otra vez el bucle del 01:53:31

Update, al meterse aquí, 01:53:33

el Transform Position coja 01:53:35

desde el punto de partida. 01:53:37

Por eso era 01:53:39

relevante 01:53:41

distinguir este Transform Position 01:53:43

aquí con el de 01:53:45

aquí. Realmente 01:53:47

se podría ir haciendo 01:53:49

y se podría ir refrescando si el Transform Position 01:53:51

en todo momento 01:53:53

se va actualizando. 01:53:55

Pero puede 01:53:57

generar conflictos si hacemos esto. 01:53:59

Como está cogiendo su propia posición 01:54:01

y la está guardando dentro de la variable, 01:54:03

se va realimentando y 01:54:05

funcionaría. Pero 01:54:07

en ciertos momentos nos puede dar conflictos 01:54:09

el que no esté 01:54:11

diferenciado 01:54:13

ambos conceptos. ¿Qué hemos 01:54:15

conseguido con esto? Que ahora cuando 01:54:17

vayamos al juego, si yo le doy al Play, 01:54:19

¿vale? Veis 01:54:21

que hasta que se ubica donde está 01:54:23

la cámara, da 01:54:25

este ligero bote. Vamos, que no es bote, 01:54:27

es que está suavizado. ¿Cuánto 01:54:29

tarda en ir de una posición a otra? 01:54:31

Dependerá de 01:54:33

el Smooth, del tiempo 01:54:35

suavizado que le pongamos. Si 01:54:37

por ejemplo ponemos 5 segundos, 01:54:39

vais a ver que 01:54:41

esta variación 01:54:43

tarda bastante más. 01:54:45

Dejo de mover y ahora 01:54:47

va otra vez ahí hasta que llegue 01:54:49

a la posición destino 01:54:51

con decalaje que tiene que llegar y ahí para. 01:54:53

No estoy moviendo nada. Ahora subo, subo 01:54:55

y dejo de pulsar. 01:54:57

El decalaje, el tiempo de suavizado 01:54:59

tarda. A veces es demasiado, 01:55:01

es excesivo, por eso 01:55:03

a lo mejor un valor de 0.5 01:55:05

por ejemplo, nos permite 01:55:07

hacer estos suavizados. Que ya os digo 01:55:09

que en la rotación también podríamos 01:55:11

trabajar con Smooth Dumps, 01:55:13

matemáticos, 01:55:15

porque serían 01:55:17

en uno de los ejes, aunque ya hemos visto que 01:55:19

puede dar problemas 01:55:21

trabajar con los ángulos Euler 01:55:23

para ciertas cosas, ¿vale? Y lo que 01:55:25

conseguimos es eso. Mira, paso el suelo y hasta que 01:55:27

lo traspasa no es instantáneo. 01:55:29

Es una suavización, 01:55:31

no sé si se diría así, 01:55:33

un proceso de suavizado 01:55:35

del movimiento. 01:55:37

Con esto se explica el Smooth Dump que como 01:55:39

os he visto antes, 01:55:41

esto sirve 01:55:43

para variables, 01:55:45

para struct de vector3, 01:55:47

pero hay otro que es 01:55:49

para hacer exactamente lo mismo 01:55:51

pero con valores float, 01:55:53

con un 01:55:55

solo 01:55:57

valor. 01:55:59

Y si veis el ejemplo que hay aquí, por ejemplo, 01:56:01

dice float new position y hace 01:56:03

Smooth Dump de valor 01:56:05

del eje Y y el eje Y. 01:56:07

Y luego cuando vamos al vector3 solo 01:56:09

está usando el Smooth Dump 01:56:11

en esa 01:56:13

posición, en ese índice 01:56:15

del vector. 01:56:17

La rotación, por ejemplo, si el suavizado 01:56:19

solo lo quisiéramos en el eje 01:56:21

Z como estábamos buscando antes, 01:56:23

para el suavizado, se podrían 01:56:25

usar también Smooth Dumps. 01:56:27

Habría que dar alguna vuelta 01:56:29

pero el funcionamiento es un poco 01:56:31

similar. 01:56:33

Y nada más. 01:56:35

A ver, creo que ya no estáis ninguno, 01:56:37

que os habéis marchado, etc. 01:56:39

Sí, vale. 01:56:41

Lo dejo aquí grabado y muchas gracias. 01:56:43

Es un poco enrevesado todo, 01:56:45

lo importante es que os vayáis poniendo con la 01:56:47

tarea e ir haciendo poco a poco 01:56:49

los distintos hitos que se van pidiendo. 01:56:51

Las tareas son largas 01:56:53

para que 01:56:55

vayáis 01:56:57

practicando cada una de las cosas, 01:56:59

que son muchas. 01:57:01

A veces si os bloqueáis en una, 01:57:03

seguramente otras las podáis 01:57:05

ir avanzando en lo que os bloqueéis. 01:57:07

Me podéis escribir en el foro, etc. 01:57:09

Voy a retrasar la entrega de esta práctica 01:57:13

una semana, yo creo. 01:57:15

Los que ya la tengáis me la podéis 01:57:17

entregar y poneros con la siguiente. 01:57:19

Pero bueno, 01:57:21

si alguno le ayuda a tener un poquito más 01:57:23

de margen, dado que la semana que viene no voy a poder 01:57:25

dedicarlo mucho a correcciones, 01:57:27

pues 01:57:29

nada, doy ese margen. 01:57:31

Nada, muchas gracias 01:57:33

y 01:57:35

un saludo. 01:57:37

Tutoría 4 - DEIM - UT2 - Curso 23·24 -11 Enero - Contenido educativo

Del mismo autor…

Talleres de los sentidos

Adrián

Martina

CIRCLASSICA

CALANTHA_Elfos en el CEIP Luis De Góngora de Madrid

ELENTAN e ISILDUR_Elfos en el CEIP Luis De Góngora de Madrid

MELIA y ALBRUM_Exposición de Elfos en el CEIP Luis De Góngora de Madrid