Tutoría 9 - DEIM - UT5 y 6 - Curso 24·25 - 25 Marzo

Bienvenidos a la tutoría 9. Bueno, no he visto, voy a volver a mirar, no he visto ninguna duda en el foro. 00:00:01

Dame un segundo, me voy a refrescar, ni en los apartados. Por tanto, entiendo que no hay así ninguna duda concreta que me queráis plantear, ¿verdad? 00:00:13

Si no, pues empezamos por eso, pues para tenerlo en cuenta o resolverla cuanto antes, vaya. 00:00:21

A ver, estoy revisando, pero vamos, que antes de Mirai no había ninguna entrada nueva en los foros, así que dudas, al menos cuando las planteéis ahora, no hay. Vale, me está escribiendo. 00:00:27

Vale, duda no hay, me atasqué la parte de los nodos, entiendo que te refieres al animator. Vale, a los nodos y cómo conectarlos. Pues ahora lo vemos. No sé si en general o en algún caso concreto o es en todo y lo vemos. Vale. 00:00:46

¿Vale? Venga 00:01:01

Pues de primeras 00:01:04

primeras dudas, hablamos sobre 00:01:05

el Animator Controller 00:01:07

¿Vale? Decidme más 00:01:10

cosas por si acaso, para tenerlo en cuenta 00:01:12

Vale, pues 00:01:13

vamos con esa parte y luego 00:01:21

si no me vais, me vais diciendo 00:01:23

Sí, para avanzar desde el Animator al movimiento 00:01:24

del personaje en sí, vale, fenomenal 00:01:27

Voy a hacer un 00:01:29

repasillo rápido hasta llegar ahí 00:01:31

¿Vale? Voy a ir muy rápido porque entiendo que 00:01:33

eso sí, los que ya habéis empezado 00:01:35

habéis avanzado hasta ahí pues más o menos lo entendéis y no hay dudas vale 00:01:37

bueno os proporcionaba en la tarea a ver está aquí en sprites pues varios 00:01:43

sprites algunos que son imágenes sueltas como ya habréis visto si por defecto no 00:01:48

las está cogiendo estos sprites igual que sucedía en las imágenes de y por 00:01:55

ejemplo de los botones tienen que ser texturas del tipo 2d y yu hay vale y una 00:02:01

vez puesto hay que aplicar esta actualización y aparte de eso también había otras hojas de 00:02:05

sprites en este caso que como veis pues tienen se componen de diversos de diversos sprites en 00:02:10

sí bueno aquí ya aparecen con esta flechita porque ya los he dividido dividido esta hoja 00:02:16

de spray si os fijáis aquí en estos cuadradetes que es una operación rápido también lo cuento 00:02:21

porque lo ponen creo suficientemente desarrollada en el temario que hay que cambiar que al clicar 00:02:28

Estamos en el panel de proyecto y en el inspector que se abre cuando vamos seleccionando estas hojas de sprites o estos sprites a seca, vaya, estas imágenes. 00:02:35

Si queremos que se interprete uno de estos diseños como una hoja de sprites, es decir, que hay múltiples sprites independientes o que vamos a usar de manera independiente, 00:02:44

en vez de usar la modalidad de single que viene por defecto, tenemos que decir que sea de tipo múltiple. 00:02:54

Es decir, de este mismo archivo va a extraer varios diseños, como por ejemplo vemos aquí las distintas miniaturas que se corresponden en este caso con diferentes animaciones. 00:03:00

No siempre tienen que ser animaciones, lo que se guarda en una hoja de sprites, pero es una de las razones por las que se hace esto para tenerlo agrupado en una hoja de sprites. 00:03:11

Y dentro de esa hoja de sprites hay una sección que se llama sprite editor, que aquí nuevamente ya está dividido y en las instrucciones de la tarea, en el enunciado, os indicaba de cuánta área es o para qué está pensado la división de esta hoja de sprites, que pone que es de 275 por 275 píxeles, que eso se hace con la opción de slice e indicando el tamaño del grid. 00:03:21

Aquí no lo voy a hacer de nuevo, pero aquí es donde definimos la medida que tendrá, que coincide con la división que luego he hecho. Cada uno de los sprays, tal y como se sacaron, esto es algo que tiene que venir ya previsto desde el diseño de esta hoja de spray, ¿cuánta área es en la que ha ido segmentando una animación en este caso? 00:03:46

Una vez se pone, también es relevante en esta división, en este slice, indicar que en este caso, claro, los ojos, los pies del personaje van a estar en la parte inferior 00:04:11

Entonces el pivote, es decir, el punto que tiene de referencia para los movimientos, rotaciones, etcétera, más conveniente es que sea desde estos pies 00:04:25

Por tanto en esta operación, en otros casos puede ser otro el punto que nos interese, o también lo podemos ir ajustando a mano 00:04:33

a más no me refiero a que en custom se puede establecer que sea otro 00:04:40

las coordenadas, pero bueno, por lo general es verdad que no está 100% posado 00:04:47

en lo que es el límite de estas divisiones según las hacemos 00:04:52

pero bueno, más o menos sí que queremos que esté en esa parte inferior 00:04:56

y una vez ya lo tenemos, bueno aquí eso no lo quiero aplicar 00:04:59

porque ya está dividido, si no hay duda 00:05:04

una vez le diéramos a ese botón 00:05:07

de slice, pues hace 00:05:10

estas divisiones y aquí es cuando 00:05:12

lo descarto, lo que he hecho 00:05:14

cuando ya sí que nos sale este desplegable 00:05:15

con las distintas divisiones 00:05:18

independientes de cada 00:05:20

bueno, pues de cada división que hemos hecho en esa 00:05:21

hoja de sprite 00:05:24

una vez tenemos eso 00:05:25

normalmente lo que vamos 00:05:27

a generar, que a veces 00:05:30

no es lo más intuitivo, es 00:05:32

que podemos meter uno de estos sprites 00:05:33

Por ejemplo, uno de estos elementos, me voy a poner en la pantalla que hay que hacer las ediciones, recordad no liaros entre la de juego, que es para previsualizar el juego, y la de escena, aquí podríamos arrastrar a la jerarquía o a la propia escena uno de estos, en este caso es el personaje, una de estas divisiones. 00:05:36

En este caso vais a ver que cuando yo le dé aquí se va a quedar estática. Aquí veis ya, si no se ve lo hago con un pequeño zoom, que tiene una ligera animación. Pero por defecto cuando metemos un personaje, esto es importante, hago un inciso y tiene que ver con la duda que estáis planteando. 00:05:56

Cuando tenemos estas animaciones y esta sucesión en este caso de fotogramas que están ya prediseñados, al final lo que estamos haciendo por un lado es tener animaciones de un personaje que ya han sido diseñadas, como cuando se pintan dibujos animados. 00:06:19

Aquí este movimiento no está generado, es decir, este cabeceo, este meceo de las manos, no está generado por Unity en sí. Está generado porque un fotograma tras otro va desarrollando esta animación. 00:06:37

Por eso no hay que distinguir cuando, por ejemplo, ahora vayamos a una animación de que el personaje se mueve hacia izquierda o derecha, que lo que vais a ver es que lo que va haciendo es... un segundete, que me voy aquí y así lo vemos más en contexto. 00:06:51

Cuando me muevo, ¿vale? Este movimiento de piernas no es lo que está haciendo, que a veces intuitivamente lo que parece, no es lo que está haciendo que el personaje se mueva. Es decir, está haciendo una animación del personaje moviendo los pies en el sitio. Lo que va a hacer que se desplace por el espacio es que nosotros, por código, como hemos hecho ya en otras ocasiones con la nave, con la bola, etc., es lo que va a hacer que arrastre. 00:07:07

Entonces, es decir, que lo mueva en el espacio igual que que lo salte. Esta animación de saltar, si vamos a la animación de saltar, que está aquí preparada, si os fijáis, aquí hay una ligerísima... 00:07:30

Ligerísima, veis que vamos viendo la sucesión de fotogramas y hay una ligerísima elevación, pero no es la fuerza de salto que yo voy a querer. La fuerza de salto, aparte de que ya tenga este pequeño diseño de que salta, lo que va a hacer que efectivamente, y vuelvo a hacer más grande la pantalla, que efectivamente salte, aunque haga este pequeño movimiento de pies, es que le estamos aplicando una fuerza en el eje Y hacia arriba. 00:07:44

entonces eso es importante 00:08:09

y esto también sucederá cuando lo hagamos en 3D 00:08:11

hay que pensar que por un lado está la apariencia 00:08:14

visual de los movimientos 00:08:16

que en 2D 00:08:17

cuando se basa en sprites 00:08:20

se debe a que está la animación 00:08:21

ya diseñada y se está 00:08:24

en este caso reproduciendo en bucle 00:08:25

y otra cosa es el desplazamiento 00:08:27

en sí de lo que es el GameObject 00:08:30

es decir, si yo ahora voy aquí 00:08:32

al robot 00:08:35

que es este robot que tenemos aquí 00:08:36

Os lo enseño aquí. Este robot, cuando yo me muevo, está haciendo la animación y si fijáis en el cuadro, está todo el rato ese cuadro reproduciendo este grande que estamos hablando, se corresponde con las divisiones. Se corresponde con dónde está el objeto. 00:08:38

Y luego veis que toda la caja y lo que hay en su interior se desplaza hacia los lados o salta, etc. ¿Vale? Entonces lo primero que ocurre cuando, y vuelvo a este que tenemos aquí para el juego, a este que tenemos aquí es que por defecto, ¿vale? 00:08:56

Este nuevo diseño que hemos metido, por defecto, solo tiene un sprite renderer, que es el componente que permite que se visualice un sprite, ¿vale? 00:09:12

Entendido como un elemento 2D, que es el mismo que, por ejemplo, si yo pulso aquí, se ve en esta plataforma. 00:09:20

Cada uno tendrá un sprite, ¿vale? Incorporado, si vuelvo a la plataforma, fijaos que este es el iconito que representa los sprites, ¿vale? 00:09:28

cuadrado morado 00:09:36

y tiene varias opciones en sí mismas 00:09:39

que por defecto 00:09:41

en este caso no vamos a tocar 00:09:42

son interesantes, por ejemplo está 00:09:45

la de, si voy al robot otra vez 00:09:47

la de flip, y vais a ver 00:09:49

que lo que hace es voltearlo 00:09:51

y veis, fijaos también 00:09:53

que este volteo lo hace 00:09:55

no desde su centro, sino desde 00:09:56

la parte inferior, porque recordad 00:09:58

si yo le doy al volteo en Y 00:10:01

lo hace desde el suelo 00:10:02

desde los pies del personaje vamos a decir 00:10:04

porque el punto de pivote lo hemos puesto aquí 00:10:06

y nos interesa si el personaje 00:10:09

de pronto tuviera que andar al revés 00:10:11

bueno, según como fuera 00:10:13

nos podría interesar más o menos 00:10:15

pero queremos que las operaciones también 00:10:16

de rotación 00:10:18

de rotación 00:10:20

pues lo haga en base a ese 00:10:23

punto de pivote 00:10:25

porque si se echa para adelante o para atrás 00:10:26

queremos que sea desde ahí 00:10:28

por eso es importante el punto de pivote 00:10:29

pero ahora mismo yo lo que he arrastrado aquí es solo 00:10:31

un sprite, ¿vale? un elemento 00:10:35

un fotograma, y eso es lo que se está viendo 00:10:37

no hay ninguna sucesión, ninguna animación 00:10:39

de fotogramas 00:10:41

para que eso se vea, tienen que suceder 00:10:42

dos cosas, en primer lugar 00:10:45

como tenemos 00:10:47

una sucesión 00:10:49

de fotogramas 00:10:50

¿vale? de estos pequeños sprites 00:10:53

hay que, de algún modo 00:10:55

ensamblarlos para que se reproduzcan 00:10:57

uno después de otros, ¿vale? en el orden 00:10:59

que ya se ha hecho previamente en el diseño de esta hoja de spray, ¿vale? 00:11:01

Entonces, aquí tenemos una animación que fotograma a fotograma se va moviendo. 00:11:04

Para eso, existe dentro de las ventanas una primera que se llama Animation, ¿vale? 00:11:09

Y se ha abierto aquí, que es una línea de tiempo como la que conocéis con fotogramas, ¿vale? 00:11:15

Y luego, por otro lado, que es los nodos que estábamos hablando, por otro lado, esta ventana, 00:11:21

y otro concepto que es el animator 00:11:25

que es esto que tenemos aquí 00:11:28

que parece una estructura de nodos 00:11:29

yo aquí ya tengo varios conectados 00:11:32

y una y otra 00:11:34

se interrelacionan 00:11:35

ahora hacemos una muestra de cómo funciona 00:11:38

cada una, porque quiero ir más o menos 00:11:40

rápido 00:11:42

y luego ver dudas que surjan, porque esto 00:11:42

creo que está explicado, por ejemplo, en el vídeo 00:11:45

de Álvaro, aparte de en el tema 00:11:48

pero, eso, cuando tenemos aquí 00:11:50

un objeto seleccionado 00:11:52

vais a ver que está diciendo, para empezar a animar, y aquí está hablando de un GameObject concreto, veis que se llama igual, para animar este GameObject, crea un Animator y un AnimatorAnimationClip, aquí están ya referenciados o mencionados los dos elementos que se van a poner en juego, este Animator para ir incorporando, cada uno de estos nodos, ir incorporando las distintas animaciones que vayamos creando, 00:11:54

Y luego en este panel vamos haciendo estas animaciones en lo que se conocen como Animation Clips, que son distintos clips que van recogiendo, y fijaos en el icono que tienen esos Animation Clips, que es este triangulito verde, ahora os enseño alguno también de las que ya están desarrolladas, que en este caso es donde vamos incorporando los fotogramas. 00:12:19

Entonces, por un lado, la animación en sí con su línea de tiempo, tiene un tiempo, se van ejecutando animaciones y en este caso vamos a jugar con fotogramas, pero también se podría animar en el tiempo, pues por ejemplo el transform de un GameObject. 00:12:40

Meterme aquí e ir diciendo que la posición vaya cambiando en cierto momento, igual que hacemos en un objeto 3D. De hecho, vamos a hacer eso primero. De momento dejo de lado este robot y de hecho lo voy a desactivar, que es el que está preparado ya con las animaciones. 00:12:56

Nos vamos a centrar un segundo en este que tenemos aquí. A ver, perdonad, que me voy a poner la escena también aquí de momento. Ya van faltando espacios con tanto menú que tengo que abrir. Pero bueno, nos vamos apañando. 00:13:13

Entonces tenemos este robot aquí y voy a decirle, oye, yo quiero que esto, y lo voy a llamar además, para que no sea este nombre que ha cogido por defecto, robot tutoría. 00:13:27

Tutoría 00:13:41

¿Vale? Si queremos animar el robot 00:13:45

Tutoría, hay que crear 00:13:47

¿Vale? Y lo voy a crear 00:13:48

Por ejemplo, en el escritorio 00:13:50

En... Aquí, por ejemplo 00:13:53

Voy a crear una nueva animación 00:13:55

¿Vale? Y aquí es lo que hay que pensar 00:13:57

Las animaciones se van 00:13:59

Segmentando en distintos tipos, igual que las 00:14:01

Hojas de spray, viene una a andar, otra a correr 00:14:03

Otra a saltar, otra a agacharse 00:14:05

¿Vale? Pues la primera 00:14:07

Normalmente es la de estar como en reposo 00:14:09

se llamaría que es cuando no hay movimiento 00:14:11

pues el personaje pues eso tiene un pequeño 00:14:13

meceo para que se vea que está 00:14:15

en el sitio animado y no está estático 00:14:17

pues suele tener esta animación que se llama 00:14:19

el idle entonces bueno 00:14:21

por la primera que vamos a crear y voy a poner 00:14:23

idle tutoría más que nada porque por ahí tengo 00:14:25

las animaciones que 00:14:27

tenía el otro personaje para no 00:14:29

confundirlas y al crearlo 00:14:31

you cannot save to a non asset folder 00:14:32

vale si hay que ir 00:14:35

a cuando creamos 00:14:37

dentro de los assets 00:14:39

de nuestra jerarquía 00:14:41

nos ha dado ese aviso 00:14:43

pues yo por ejemplo aquí creé 00:14:45

dentro de la estructura de carpetas 00:14:47

veis que hay aquí ya una creada de animaciones 00:14:49

y aquí están las distintas animaciones 00:14:51

fijaos con este punto anim que es el que nos dice 00:14:53

aquí, las distintas animaciones en las que 00:14:55

yo ya he ido pues guardando 00:14:57

haciendo estos clips donde se 00:14:59

guardan estos movimientos 00:15:01

estos 00:15:03

animaciones de objeto 00:15:04

aquí tengo las del robot 00:15:07

Para no confundirla, nuevamente voy a hacer una que se llama Robot Tutoría, ¿vale? Y, perdona que me he ido a guardar a la escritoria y no se puede, ¿vale? 00:15:09

Idle Tutoría. Y ahí está. Y ya cuando hemos creado un Animation Clip, todos los Animation Clips que vayamos asociando a ese personaje, ¿vale? 00:15:18

Porque aquí se pueden ir creando más, irán apareciendo aquí y se irán seleccionando aquí. 00:15:27

Entonces, por ejemplo, el del idle. Yo ya he dividido, imaginaos, hemos hecho este trabajo de dividir el personaje, los distintos fotogramas y para incorporar estos fotogramas en una línea de tiempo de esta animación llamada idle, lo que hay que hacer es seleccionar todos del primero al último con shift, ¿vale? 00:15:30

A ver si lo podemos dar un poquito más de zoom. ¿Vale? Veis que por defecto lo que se van viendo aquí no hay mucha diferencia porque se ven cada fotograma en pequeñito, ¿vale? Pero esta animación es donde se puede ir ajustando, pues a lo mejor que el primer momento de reposo dure esto y luego entre fotogramas podemos ir variando la distancia. 00:16:00

Es decir, no tiene que durar un fotograma cada uno, ni dos, etc. Incluso, igual que sucede en los software de animación, aquí podemos hasta cambiar la velocidad de fotogramas por segundo. 00:16:25

Si nos parece muy rápido, muy lento. Por defecto viene en 60, yo lo voy a poner en 30 y así la animación, si no vamos desplazando los fotogramas entre sí, se irá reproduciendo a 30 fotogramas por segundo. 00:16:40

¿Esto qué significa? Que cuando ya tenemos una animación, ¿vale? Y le damos a este play, a ver, voy a escena que se verá aquí, vais a ver que ya tiene este cabeceo, porque si seleccionamos este personaje, ¿vale? Al final lo que está sucediendo es que aquí se está desarrollando esta animación y fijaos que se queda aquí unos segundos y luego empieza a moverse. 00:16:55

A ver, reproduzco de nuevo. Aquí está. ¿Vale? Es que se reproduce, se queda parado y luego ya va más rápido. ¿Por qué? Porque yo en esa animación, si os fijáis, cuando la selecciono he dejado unos fotogramas que se quedan como estancados y luego ya empiezan a desarrollarse a la velocidad. 00:17:23

Esto, cuando creamos un primer clip de animación, a través de este panel de animación, en un GameObject, que es en este caso Robot Tutoría, fijaos que por defecto, yo no lo he añadido de ninguna forma, si os fijáis, ha aparecido otro componente ya aplicado que se llama Animator. 00:17:45

Que el animator, como su propio nombre indica, está relacionado con el panel de animator 00:18:07

Y si os fijáis también, yo estoy aquí reproduciendo el juego 00:18:13

Y sin hacer nada, ya por defecto viene un primer nodo que se llama igual que esta animación 00:18:17

Y veis que hay una barra que en bucle se va llenando una y otra vez 00:18:22

En relación a lo que dura esta animación 00:18:28

Esto, aunque no se ve aquí, está reproduciendo la duración de la animación que tiene en su interior. 00:18:31

Entonces, lo que podremos ir haciendo es ir generando, por ejemplo, si yo ahora en este personaje creo un nuevo clip, que ahora va a ser salto en Tutoría. 00:18:39

Y lo vuelvo a guardar en Animations, Robot Tutoría, para tenerlos todos agrupados. 00:18:53

Al darle a guardar, aquí dice, ya tienes el Idle Tutoria en este objeto, asociado a este GameObject, y también ahora otro que se llama Salto Tutoria, que aún está vacío. 00:18:58

Cuando generamos un nuevo clip de animación, fijaos que aparte de generarse esta animación, aquí aparece otro nodo. 00:19:11

Y los nodos, además, cuando los vamos seleccionando, tienen en el propio inspector, tienen ya unida o vinculada, esto se podría cambiar si nos interesara, pero viene ya vinculada por defecto la animación. 00:19:18

Porque pensad que ese clip de animación que hemos creado aquí en Animation Robot Tutoría se ha generado un Animation Clip que aquí viene referenciado con este triángulo verde. 00:19:34

Entonces, cada uno de estos estados, por defecto, está asociado a una animación. Por ejemplo, vamos a asociar en este, lo dicho, para que podáis operar en el panel de animación con animaciones de un GameObject, hay que seleccionar ese GameObject. 00:19:44

incluso para ir comprobando la animación de esto que vayamos haciendo en el panel de animación, 00:20:04

independientemente del animator, aquí tenemos un reproductor en el panel de animation. 00:20:09

Para ver lo que está sucediendo, si nos vamos al panel de escena, en el que editamos normalmente, 00:20:14

si le damos aquí play con el objeto seleccionado, vemos esa animación tal y como está aquí. 00:20:21

Pero veis que ahora no se está reproduciendo el animator controller. 00:20:26

Ahora estamos viendo la animación como tenemos aquí. De hecho, fijaos, luego deshago, que si yo borro esto, se queda quieto, se mueve un poquito, está reaccionando todo el rato en relación a lo que vayamos haciendo en este panel. 00:20:30

¿Vale? Entonces, a ver, voy a mover estos fotogramas para que vayan hacia aquí y juntarlo con la velocidad real que quiero. Entonces aquí podemos ir manipulando los distintos fotogramas y sus duraciones. 00:20:45

Cuando luego, por ejemplo, nos metemos en salto, aquí podemos hacer nuevamente esa misma operación. 00:21:06

En los sprites, yo tengo aquí ya una hoja de sprites relacionada con el salto, que es esta que tenemos aquí, 00:21:11

y nuevamente yo lo voy a arrastrar, tras seleccionar con Shift todos los diferentes sprites, a esta línea de fotogramas, 00:21:18

que queremos ver cómo se ve, qué hace esta sucesión de distintos dibujos en este caso. 00:21:25

Pues le damos a play y se ve 00:21:31

Porque lo tenemos seleccionado y entonces se ve 00:21:33

Evidentemente hay que poner 00:21:35

La 00:21:37

La 00:21:39

La visión de escena para que se vea ese personaje 00:21:40

Pero veis que aquí se puede hacer una pequeña 00:21:44

Reproducción, ir fotograma a fotograma 00:21:46

Ir al último, al primero 00:21:48

Pues igual que se hacen 00:21:49

Los software 00:21:51

Que permiten animaciones 00:21:54

Entonces 00:21:55

Lo que vamos a conseguir por un lado 00:21:57

Con este animator es 00:21:59

pasar en ciertos momentos 00:22:01

de una animación a otra, pues cuando pulso 00:22:03

tal tecla paso de esta animación 00:22:05

de estar idle a estar en salto 00:22:07

¿vale? pero nuevamente 00:22:09

el salto en sí, si os fijáis 00:22:11

no lo está dando aquí 00:22:13

yo ahora le doy a 00:22:14

bueno, perdón, no lo quería ver 00:22:16

aquí, lo quería ver, selecciono el objeto 00:22:19

el salto no lo da 00:22:21

veis que este salto 00:22:23

que da es mínimo, es solo una animación 00:22:25

para dar la influencia de salto 00:22:27

Pero el salto realmente nosotros después lo haremos así, desplazando con fuerzas o con kinemáticas también se podría, pero en este caso se os pide con fuerzas. 00:22:29

Entonces, mientras el personaje iba con la otra animación andando, que lo iremos desplazando, en cierto momento, por ejemplo, cuando demos a la barra espaciadora, diremos pasa de este nodo a este. 00:22:38

Y aparte de hacer esa animación, también le pondremos que haga su desplazamiento en el eje Y o el que indicamos. 00:22:48

¿Hasta aquí qué tal? ¿Me seguís? 00:23:01

Sé que ya esta tarea tiene un montón de variables. 00:23:04

Por eso hay una sección que es la más compleja realmente, que es la de las torretas, que es opcional. 00:23:09

Y os dejo prácticamente el código para ir uniendo y bueno, irlo referenciando. Y es complejo, lo sé. Pero bueno, eso, irme parando e irme haciendo dudas. 00:23:14

Entonces, una vez tenemos eso, lo primero también, que no se nos olvide lo que hemos ido estudiando hasta ahora, el personaje se queda en su sitio cuando estamos diciendo de moverle en físicas, 00:23:25

porque primero no estamos aplicando ninguna física, ¿vale? 00:23:36

Que se queda ahí, pero independientemente de la animación 00:23:39

y de los movimientos que nosotros aportemos, 00:23:42

recordad que en un juego en el que vamos a basarnos en físicas 00:23:44

tiene que haber eso que se llama Rigid Body. 00:23:47

Y como pone en el tema, además cuando estamos usando sprites, 00:23:50

elementos en 2D, hay una nueva tipología de elementos basados en física 00:23:54

como este Rigid Body 2D, igual que va a haber, ¿vale? 00:23:58

Luego colliders 00:24:02

De tipo 2D 00:24:05

Que no son los mismos además 00:24:06

No son ni siquiera las mismas formas 00:24:08

Que las que había en 3D 00:24:10

Los colliders de elementos 3D 00:24:11

Ya para empezar, cuando le damos al play 00:24:13

Aparte de que esté en estado de reposo 00:24:15

Pues veis que se cae el personaje 00:24:17

Porque hay una física 00:24:19

Y no choca con este otro sprite 00:24:20

Que yo ya había metido 00:24:24

Esta plataforma 00:24:25

Que se han ido distribuyendo 00:24:26

Que nuevamente 00:24:28

Hasta que no se pone un box collider no se detectan estas colisiones. Entonces, nuevamente, igual que hacíamos en el tema 3 y 4, los objetos por físicas también tienen que verse, tienen que encontrarse. 00:24:30

Para ello existe un tipo de collider, el más básico, que puede ser o el capsule o el box collider, según la forma que queramos, cuando lo aplicamos tiene este área que sirve para definir qué sección va a encontrar cuando colisiona un objeto con otro. 00:24:44

Y hay un problema mínimo cuando lo dejamos así, que es que ahora se queda en el suelo, pero fijaos que esa pequeña diferencia que hay en el diseño del sprite, aquí es por donde estaría el punto de pivote, en el propio sprite hay un pequeño hueco que no es realista. 00:25:05

Esto se arregla, igual que sucedía en los otros colliders, con las opciones que tiene el propio collider para desfasar o ajustar medidas. 00:25:24

En este caso, por ejemplo, podemos decir, y de hecho es lo suyo, que los colliders se relacionen con la forma que tiene el personaje. 00:25:37

Porque si luego encontráramos una pared y se chocara con la pared, nuevamente se chocaría en este punto y no donde querríamos, que es más como por aquí. 00:25:47

Entonces, elementos como este ajuste de medidas hay que hacerlo de forma pertinente al diseño que tenemos. 00:25:55

Aquí hay un offset, lo ajustamos y ahora sí que si lo ajustamos aquí, pues ya tenemos que al arrancar el juego, la caja que está teniendo en cuenta para las colisiones es la de, incluso se podría ajustar un poquito más. 00:26:06

Ahora lo ajusto. Pero tiene que ver con la caja del collider. Nuevamente, que veáis un movimiento no significa que se esté moviendo en sí, ¿vale? Hay que ir combinando las distintas funciones o operaciones que podemos tener. 00:26:21

¿vale? entonces ahí 00:26:38

y lo bajo un poquico 00:26:39

y esto es importante no solo por esto 00:26:41

que estamos haciendo ahora del suelo 00:26:44

¿vale? sino porque 00:26:45

también los colliders, recordad que nos 00:26:47

pueden servir por ejemplo si nos disparan 00:26:50

aquí 00:26:51

ahí por ejemplo 00:26:53

creo que está más fino, para que detecte 00:26:58

las balas, por ejemplo, entonces 00:27:00

si al personaje de pronto le ponemos una caja 00:27:02

que sobresale muchísimo por arriba 00:27:04

¿vale? pues una bala que a lo mejor 00:27:06

Si llega hasta aquí el collider, llega aquí la bala, mata al personaje porque está detectando la colisión. Le voy a hacer un pelín más ancho y ya lo tenemos. Ahí, más o menos. Hay otros tipos de formas de colliders que incluso podrían ser más convenientes como un cápsule porque tiene una forma más redondeada y entonces estas aristas, pero bueno, esta podría servir. 00:27:08

Recordad luego, por ejemplo, cuando se agachara el personaje 00:27:29

Que cuando se agache el diseño, el sprite 00:27:33

Puede parecer que el personaje está así 00:27:39

Pero la caja del collider no 00:27:40

Habría que actualizarla por código 00:27:42

Para que, por ejemplo, cuando se agache 00:27:44

Pues sea así, ¿vale? De grande 00:27:45

Que si os fijáis en el otro objeto que tenía 00:27:48

¿Vale? Ya que estoy hablando de esto 00:27:51

Os lo enseño en un segundito 00:27:53

aquí, vale, si voy 00:27:54

a ese otro personaje que tengo 00:27:58

vale, bueno, yo le doy al play 00:28:00

ahora se va a cambiar 00:28:02

a la de game, pero vuelvo aquí 00:28:03

bueno, espera, lo pongo aquí la de game 00:28:05

y voy a dar un poquito 00:28:07

menos de espacio a esto, cuando yo voy moviendo 00:28:09

al personaje y lo agacho 00:28:11

veis que en algún momento 00:28:13

estoy actualizando 00:28:16

esa colocación 00:28:17

del boss collider, ver que se cambian 00:28:19

las dimensiones, vale, estoy metiéndose 00:28:21

en el componente Backbox Collider 00:28:23

por código, algo que ya vamos sabiendo 00:28:25

hacer, ¿verdad? 00:28:27

Y pues habrá que decir offset en X 00:28:29

en este momento 00:28:31

0, si yo pulso la letra control es 00:28:33

0,35. 00:28:35

Se puede ir ajustando visualmente 00:28:37

y luego por código se meten esas 00:28:39

medidas. 00:28:41

¿Sí? Bueno. 00:28:43

Hasta aquí más o menos me vais siguiendo. 00:28:45

Y me meto más con el 00:28:49

Animator Controller. 00:28:51

Vale. Animator Controller. 00:28:53

Pues lo dicho, cuando he añadido estos clips de animación al robot que hemos incorporado, a medida que vaya asociando más o menos animaciones a ese objeto, más de estos nodos irán apareciendo. 00:28:55

que ojo, aparecen por defecto 00:29:12

pero yo lo puedo borrar 00:29:15

borrándolo 00:29:17

que porque se haya creado 00:29:19

con el objeto seleccionado 00:29:20

se puede aparecer aquí pero en cierto momento 00:29:23

no puede sobrar y borrarlo 00:29:25

o más interesante entiendo porque esto si no lo unimos 00:29:26

pues ahí está y tampoco pasa nada 00:29:29

estos triangulitos hemos dicho que son los 00:29:30

clips de animación, entonces yo puedo coger 00:29:33

uno y meterlo aquí 00:29:35

que es un nodo que representa esa animación 00:29:36

¿vale? entonces 00:29:39

incluso, esto lo vais a ver 00:29:40

en el siguiente tema 00:29:43

cuando hagáis animaciones de objetos 3D 00:29:44

y a lo mejor tenéis un rig 00:29:47

del cuerpo y vais a meter 00:29:49

otra animación compatible con 00:29:51

ese rig de cuerpo, que venga 00:29:53

de otro sitio, de Mixamo, esto cuando veáis 00:29:55

el tema 6, lo veréis 00:29:57

claro, que no venga con 00:29:58

el mismo FBX, con la misma 00:30:01

geometría 3D, no significa que no podamos 00:30:03

incorporar otras animaciones que venían 00:30:05

de otro sitio, siempre y cuando 00:30:07

en el caso de 3D, pues estén relacionados 00:30:08

bien los puntos de rigging con el 00:30:11

avatar, con el esqueleto 00:30:13

inicial, ¿vale? Esto ya lo veremos, pero que 00:30:15

sepáis que va a ser incluso frecuente 00:30:17

coger animaciones de distintos modelos 00:30:19

e incorporarlos al mismo animator 00:30:21

para luego ir pasando de uno a otro, ¿vale? 00:30:23

Esto tendrá más sentido probablemente 00:30:25

en el futuro, pero aquí también, yo por ejemplo 00:30:26

ahora mismo, cojo 00:30:29

este robot walk que hice en otro 00:30:31

momento, ¿vale? Es verdad que aquí, si me 00:30:33

fijo, es el mismo robot porque es el 00:30:35

mismo dibujo, ¿no? Entonces yo 00:30:37

si yo ahora fuera a este objeto que tengo aquí 00:30:39

a este robot 00:30:41

tutoría 00:30:43

si le digo 00:30:43

que 00:30:47

por defecto 00:30:48

el que quiero que 00:30:51

se haga, ¿vale? Sea 00:30:53

dame un segundo y ahora os explico esto, sea este 00:30:54

robot walk, vais a ver que ya el que se está 00:30:57

reproduciendo en ese game object es el 00:30:59

que está caminando, fijaos que 00:31:01

está caminando o parece, pero no 00:31:03

se mueve, solo está haciendo una animación en el sitio 00:31:05

como está diseñado 00:31:07

pero no se mueve en el espacio 00:31:11

entonces eso, que sirve para ir conectando 00:31:14

distintas animaciones entre uno y otro 00:31:18

un concepto interesante que es esto 00:31:19

por lo que algunas cajas se ven en naranja 00:31:22

es este concepto de que dando clic con botón derecho 00:31:25

podemos fijar uno de estos estados 00:31:29

estos nodos se llaman estados 00:31:31

como el que surge por defecto 00:31:33

Y ese va a ser el que se anime de primeras 00:31:35

Es decir, yo cuando dé al play 00:31:41

Va a empezar la animación desde ese primer nodo 00:31:43

Yo lo llamo nodo, pero bueno, sería más correcto decir desde ese primer estado 00:31:48

Entonces, aquí hay un nodo de entrada 00:31:52

Que es cuando entres en el nivel 00:31:54

Ve al que esté conectado aquí 00:31:55

Que va a ser por defecto ese, que es el naranja 00:31:58

Si yo pusiera este, veis que el que se está reproduciendo es este 00:32:00

¿Vale? Entonces, una vez tenemos esto, más ingredientes 00:32:02

De estas animaciones que hemos creado, si nos vamos metiendo en las distintas animaciones 00:32:07

En la animación en sí, no en el nodo, en la animación en sí, en el panel proyecto 00:32:11

Vais a ver que hay tres opciones, bastante relevantes las tres 00:32:15

Pero ahora mismo nos interesa sobre todo una 00:32:19

Más para 2D, una que es que se haga en bucle 00:32:23

Es decir, si yo desactivara en la de salto, por ejemplo, tendría 00:32:27

y tiene sentido que esto del bucle 00:32:30

se desactive, porque cuando saltamos 00:32:33

queremos que el salto, la animación de salto 00:32:35

sea una vez y no se siga 00:32:37

haciendo el salto 00:32:39

si queremos que haga doble salto, pues lanzaríamos 00:32:40

otra vez, daríamos a lo mejor a la barra espaciadora 00:32:43

y se le haría 00:32:45

otra vez la animación, pero no queremos 00:32:47

que se haga un bucle, entonces mira, de hecho la de salto 00:32:49

la 00:32:51

desconecto, ¿vale? y la de idle 00:32:51

por defecto ya viene en bucle y por eso 00:32:55

pues se está haciendo en loop, ¿vale? importante porque 00:32:57

Porque si no, por mucho que aquí parezca que esto es un bucle infinito, fijaos que si yo voy a esta animación y se lo quito, bueno, espera, que lo estoy haciendo aquí, y ahora mismo, este idle tutorial no se debería reproducir en bucle, y ahí se ha parado, ¿vale? 00:32:59

fijaos que se ha parado y si voy al animator 00:33:22

aquí aunque ponga que se está reproduciendo 00:33:24

fijaos que no se mueve 00:33:26

¿vale? 00:33:28

bueno, pues es importante que esto esté 00:33:30

activo, ¿vale? 00:33:32

porque es la animación de base que hay 00:33:34

el bucle seguirá reproduciéndose 00:33:35

por... según el animator 00:33:37

pero la animación no, ¿vale? 00:33:40

pueden ocurrir estas cosas 00:33:42

vamos ahora a lo que es 00:33:43

las conexiones 00:33:46

o como pasamos de un estado a otro 00:33:48

y para esto voy a ir al que ya está hecho 00:33:50

voy a hacer un primero muy básico 00:33:53

para que veáis el del salto por ejemplo 00:33:55

que es 00:33:57

que se deben crear entre estas animaciones 00:34:00

distintos, lo que se llaman transiciones 00:34:03

para hacer una transición se clica 00:34:05

con botón derecho en el 00:34:07

nodo del que queremos que se vaya 00:34:09

y luego aparece 00:34:11

esta flecha que debemos arrastrar 00:34:13

al nodo que queremos que se vaya 00:34:15

yo quiero que vaya en algún momento 00:34:17

Todavía no hemos dicho. En algún momento pase de aquí a salto tutoría. Y de hecho, si por defecto le doy, fijaos, que yo le doy aquí y se ha reproducido este idle tutoría, ha pasado directamente a salto tutoría y se ha reproducido y ya se ha quedado ahí parado porque no está en bucle. 00:34:19

Si yo ese lo pusiera en bucle, en principio, nuevamente, fijaos lo que pasaría. Ahora está haciendo reproducciones en bucle porque nada hace que salga de este nodo y a esto le hemos dicho que sea en bucle. 00:34:38

Entonces es importante ir definiendo qué es loop y qué no es loop para que se vayan realizando estas lógicas de ir una animación tras otra. 00:34:52

Entonces, estas animaciones, normalmente, cuando ponemos una que va de un estado a otro, también es muy frecuente, siempre tiene que ser así, que luego se pase de esa a la primera. 00:35:02

Por ejemplo, en este caso queremos que empiece estando parado, que cuando pulsemos, y aquí pondremos una condición, cuando hemos clicado en esa transición, pondremos una condición que cuando se cumpla pasará a salto, y cuando se ejecute el salto, si no lo ponemos en bucle, aquí habrá otra condición que volverá al idle. 00:35:15

Si queremos que el objeto, que el personaje en este caso, esté quieto hasta que pulsemos la barra espaciadora, salte y luego vuelva a estar tranquilo una vez caiga, 00:35:39

pues ya tenemos un poco la lógica de primero va a ir, va a empezar en este, porque es el que hemos puesto por defecto, va a hacer el salto y luego va a volver a idle. 00:35:48

¿Sí? ¿Qué ocurre ahora mismo? Que como no hay condición, en cuanto se ejecuta la primera, pasa la segunda y ahora está yendo de una a otra. 00:35:56

A ver, joder, esto es verdad que se me ha ido la interfaz. De hecho, esto de game lo voy a poner aquí. No, lo voy a poner aquí abajo porque no quiero que se vea mucho. Y ahora mismo ahí. Nos viene mejor. 00:36:10

Vale, pues lo dicho, que se va a animar, va a llegar al final, va a pasar al siguiente salto y va a estar en un bucle infinito. ¿Qué es lo que vamos a hacer con estas transiciones y las condiciones de las transiciones? Pues parar estas reproducciones según nos interesa a nosotros o que pase de una a otra según nos interesa a nosotros. 00:36:28

por ejemplo, ya pensando 00:36:46

aquí querremos que suceda el salto 00:36:48

cuando, por ejemplo, pulse la barra 00:36:51

espaciadora, ¿vale? pero cuando 00:36:52

haga el salto, es muy normal 00:36:54

a lo mejor, que pase ya 00:36:56

directamente, sin ninguna condición, es decir, que cuando 00:36:58

acabe esta, vaya a esta, para 00:37:00

para que se quede tranquilo al saltar 00:37:02

es verdad que normalmente habría otra animación de 00:37:04

después de saltar, una de 00:37:06

la reacción, cuando llega al límite, es la animación 00:37:08

de la bajada del salto 00:37:10

pues habría otro nodo aquí, imagina 00:37:12

que fuera este, que habría que conectar 00:37:14

En vez de así, así, ¿vale? Que cuando se haga el salto, al llegar arriba se verá cómo cae, ¿vale? La animación de cómo cae y luego de esta irá a esta, ¿vale? Que las direcciones que van tomando estas animaciones son las que nosotros queramos, ¿vale? Pero que sepáis que eso también es muy frecuente, que haya de ida y vuelta con distintas condiciones, ¿vale? 00:37:16

Entonces, ¿cómo hacemos estas condiciones? Porque el kit de la cuestión ahora es poder gestionar cuando se pasa de una animación a otra. Y fijaos, voy un segundo, porque veáis el controller. 00:37:37

Y bueno, importante porque lo he dicho, pero igual no de la manera suficientemente clara. Todo esto que estamos trabajando y que se está guardando de la configuración de nodos, transiciones, etcétera, se está guardando, está representado en este objeto, en este asset, que en este caso ha cogido el nombre por defecto, Robot Tutoría, que es un objeto de tipo Animator Controller. 00:37:51

Igual que hay clips de animación, esos clips de animación luego se meten como estados en un animator controller. 00:38:18

En un objeto, si no hemos creado nosotros uno específicamente, como habéis visto, al crear la primera animación, 00:38:25

se crea este primer animator y se incorpora ya directamente. 00:38:30

Aquí nuevamente, si nosotros quisiéramos, con clic derecho en esta área, vamos a crear. 00:38:34

Todo esto lo podemos hacer nosotros a voluntad. 00:38:40

Podemos hacer otro animator controller, ¿vale? Que se llame robot tutoría días pares y que sea el que use en el componente animator, ¿vale? Si yo lo arrastro, veis que coge el que yo arrastro aquí, este ahora está vacío, pues a lo mejor, imaginaos, una chorrada, pero el personaje va a tener unas animaciones diferentes según el día o la hora del día en el que se arranca el juego y por código conseguimos detectar qué hora del día es. 00:38:42

Pues aquí luego podríamos tener distintos sistemas de estados, distintos animators controles y según el que nos interese, pues se carga uno u otro, ¿vale? Entonces, que sepáis que todo se gestiona aquí, ¿vale? En 3D también existe este concepto del avatar, que es lo que os había dicho antes del rigging, ¿vale? Que va a ir siguiendo las animaciones, aquí no tiene tanto sentido, esto de Apply Room Motion también lo veremos en el futuro, ¿vale? 00:39:11

Y aquí hay una cosa que os pongo en los apuntes, que no es muy importante y por eso no quiero liar, que es que también los fotogramas o el cálculo de todo lo relacionado con el animator se haga según el update, ¿vale? O según, digamos, por decirlo rápido, la gestión de tiempo de las físicas. Recordad ese physics update, que no eran los mismos tiempos que los del update, ¿vale? Pues con esto podemos cambiar que el refresco se haga de una forma u otra. 00:39:35

Que nos puede interesar, incluso ya en esta tarea 00:40:02

Si ahondáramos mucho 00:40:04

Nos podría interesar, porque teniendo en cuenta 00:40:06

Lo voy a dejar en normal 00:40:09

Aunque se podría poner perfectamente en Animate Physics 00:40:10

Tener en cuenta que los movimientos 00:40:12

Que hemos dicho que vamos a hacer del personaje 00:40:14

Del personaje, no de las plataformas 00:40:16

¿Vale? Ahora hablamos de eso 00:40:18

Van a ser en base a física, le vamos a dar fuerzas 00:40:20

Entonces queremos que estas reacciones 00:40:22

También se calcuren en base a físicas 00:40:25

Así que bueno, tampoco va a haber una 00:40:26

Diferencia muy amplia 00:40:28

Pero bueno, de hecho, incluso ya con esta lógica que tenemos, tendría más sentido poner el AnimatePhysics. 00:40:30

Vale, vamos a hacer, lo voy a hacer rápido, porque no hay tiempo y prefiero casi que lo veamos ya sobre algo hecho, ¿vale? 00:40:36

Y voy comentando código que tengo yo, o otros ejemplos que ir haciéndolo todo, que tardaríamos muchísimo y no daría tiempo casi nada, ¿vale? 00:40:44

Pero en este robot voy a hacer un script, lo voy a hacer aquí, pues yo qué sé, voy a crear un script, 00:40:51

Se va a llamar Robot Tutoría 24-25. Por si yo en el futuro lo quiero ver, saber de qué año es. Un nombre cualquiera. Esto es regular porque no debería tener números, pero me lo va a admitir. 00:40:58

Pero en principio no uséis números. 00:41:12

Mira, de hecho, voy a poner 24 con letra. 00:41:15

Y recordad, ya me sirve de recordatorio, que si abrís una script que el nombre de su clase no está escrito igual, no lo va a detectar. 00:41:20

Entonces se tiene que llamar igual. 00:41:31

Esto era de la lección 1. 00:41:32

Entonces yo tengo este robot tutoría y se lo voy a aplicar al objeto que quiero que controle, que es el de robot tutoría. 00:41:34

¿sí? hasta aquí lo de siempre 00:41:40

¿qué es lo que vamos a hacer? 00:41:42

vamos a ir cambiando 00:41:45

o aportando 00:41:47

distintos parámetros 00:41:48

que sirvan para ir definiendo 00:41:50

condiciones 00:41:53

y si os fijáis, aquí hay algo de layers 00:41:54

las layers son más 00:41:57

complejas y más avanzadas 00:41:59

en el tema 6 algo se apunta pero es más avanzado 00:42:00

y es más para 3D de hecho, no es para esto 00:42:03

que son cada una de estas 00:42:05

igual que os he dicho antes de que se podían ir cargando 00:42:07

distintos animators controllers vale también dentro de un mismo animator controller se pueden 00:42:09

ir haciendo distintas layers vale y que cada una vaya se vayan activando no y vayan guardando o 00:42:14

lanzando distintas nodos de animación incluso se puede combinar que la parte de arriba de un 00:42:20

cuerpo en un 3d en un objeto 3d pues el torso se mueva en base a unas animaciones y la parte 00:42:25

inferior en otra entonces se pueden ir combinando distintas pero esto es más avanzado entonces de 00:42:30

momento vamos a trabajar en la base layer pero aquí hay otra sección que se 00:42:36

llaman parámetros y estos sí son ya importantes los parámetros los 00:42:39

parámetros como indica el nombre van a ser distintas vamos a decir variables 00:42:44

vale dentro de este ámbito de las animaciones que nos sirven para ir 00:42:50

aplicando condiciones vale los parámetros y las condiciones están 00:42:55

íntimamente ligados porque aquí lo que vamos a ir añadiendo en estas 00:42:59

condiciones son parámetros vale que según su valor o no pues permitirán que 00:43:03

esa condición se cumpla o no veis que sin ahora mismo le digo añadir una 00:43:07

condición dice no si es que no existe ningún parámetro efectivamente todavía 00:43:11

no lo hemos creado vale entonces parámetros hay de cuatro tipos ahí y 00:43:15

además los van a sonar todos ya parámetros basados en floats que son 00:43:20

números que pueden tener decimales no voy rápido vale ins que aunque yo meto 00:43:26

decimales? Pues me va a decir que 00:43:31

nanain, ¿vale? Y me lo va 00:43:33

a redondear. 00:43:35

Bulls, que como las booleanas pueden ser 00:43:37

verdaderas o falsas. Y luego 00:43:39

otro concepto que es trigger, con este circulito, que es 00:43:41

que según le das, se activa, 00:43:43

es un disparador, según le das le activas 00:43:45

y vuelve al reposo, ¿vale? Parece 00:43:47

lo mismo que una booleana, pero una booleana tú 00:43:49

le dices true y se queda en true hasta que le 00:43:51

digamos false. En un trigger 00:43:53

es como que se lanza, 00:43:55

¿vale? Lo dejo aquí, 00:43:57

se lanza 00:43:59

Y en principio, ahora porque no está habiendo más operaciones, pero en principio ya se desmarca enseguida. Es como para acciones momentáneas que hay que lanzar, como un salto. En un salto decimos saltar, se salta y ya está. No queremos estado de saltar, activo, true. Luego quitarlo, falso. Se podría también, pero es otra forma. 00:43:59

Entonces, podemos ir creando varias 00:44:20

Y es importante que hay que darles un nombre 00:44:23

Por ejemplo 00:44:25

Y para ir haciendo ya algo concreto 00:44:28

Voy a ir borrando 00:44:31

Se pueden poner todas las que queramos 00:44:32

Y del mismo tipo se pueden poner varias 00:44:33

Cada una tendrá un nombre 00:44:36

Y iremos diciéndole valores 00:44:38

Entonces 00:44:40

Vamos a este robot 00:44:43

Para ir accediendo a estos parámetros 00:44:46

importante, hay que primero acceder a 00:44:49

hay que crear una variable de tipo animator 00:44:54

¿vale? recordad, esto nunca es mal momento para 00:44:59

volver a decirlo, que estos son componentes y cada componente ya os he dicho 00:45:03

que es fragmentos de códigos que se han encapsulado y alguien lo ha programado 00:45:07

para que se vean estos campos, a los que podemos acceder normalmente, casi siempre 00:45:11

poniendo este nombre, entonces si yo quiero acceder a 00:45:15

las opciones del animator 00:45:18

¿vale? del animator 00:45:21

y al animator controller, lo primero que habrá 00:45:23

que hacer es capturar ese panel 00:45:25

animator, entonces por ejemplo 00:45:27

voy a hacer, normalmente 00:45:28

al animator se le suele llamar 00:45:30

anim, ya he creado una caja 00:45:33

que va a referenciar a la clase 00:45:34

¿vale? si me pongo aquí a la clase 00:45:37

de Unity Engine Animator 00:45:38

¿vale? y como siempre, lo primero 00:45:41

normalmente, ¿no? digo, que hay que 00:45:43

hacer es, hacer este GetComponent 00:45:45

en animator, etc. ¿Vale? Incluso si ya le doy 00:45:47

al tabulador, con la sugerencia 00:45:49

que tiene, aquí ya he capturado 00:45:51

que en esta variable llamada anim 00:45:53

pueda acceder a los 00:45:55

valores del animator. 00:45:57

¿Vale? Por eso cuando yo pongo anim, punto, 00:45:59

pues salen cosas como 00:46:01

esto de 00:46:02

getBull, setBull, 00:46:04

¿vale? 00:46:08

Quiero 00:46:13

alguno de los que salgan aquí. Fijaos, 00:46:13

esto de applyRootMotion, pues habrá una 00:46:15

de RootMotion. Pues yo ahora veo, 00:46:17

Mira, ApplyRootMotion. Y yo aquí ya podría acceder a ese parámetro. Para acceder precisamente a los parámetros, a estos parámetros, en el tema, voy a abrir un segundo el tema. 00:46:19

lo tengo, no, dame un segundo 00:46:32

que lo abro aquí, en una de las secciones del tema os pongo 00:46:36

varios de los métodos que se pueden usar 00:46:40

a ver, pa pa pa, directriz 00:46:44

animation, vale, ya estoy llegando 00:46:48

lanzar transiciones 00:46:50

parámetros, vale, que son 00:46:54

Esto es de aquí, ¿no? Anim, ¿vale? Y por eso lo explicas, es lo mismo que tenemos aquí. Podemos incluso acceder al animator de otro objeto si lo arrastramos por un serialize field, ¿vale? Pero eso, existen set trigger, set pull, set float, set, ¿cuál sería la otra? set int, ¿vale? 00:46:59

Y entonces, con esto, lo que podemos ir haciendo es establecer el valor del parámetro. Entonces, ¿qué quiere decir? Imaginaos que yo quiero fijar o decir, y esto lo voy a llamar, que va a ser el trigger que sirve para el salto, ¿vale? 00:47:18

Y ojo, este nombre va a ser un string que luego vamos a usar, ¿vale? Pues si yo lo que quiero es que cuando, if, y vamos a hacer uno, if input get key down, ¿vale? Cuando pulse una tecla, que en este caso va a ser la barra espaciadora, vamos, space, ¿vale? 00:47:36

Que cuando eso ocurra, yo voy a decirle que este disparador efectivamente se ejecute, ¿vale? Set, en este caso es trigger, ¿vale? Pero igual que había cuatro tipos de parámetro, aquí son todos iguales. Solo hay que cambiar el nombre del tipo de parámetro que es. 00:47:57

estará el setTrigger, estará el setBull 00:48:16

estará el setInt 00:48:19

vale, mira, si yo empiezo a escribir 00:48:21

aquí, pues me empieza 00:48:22

a ayudar, setInteger 00:48:25

vale, pero en este caso lo que queremos es 00:48:26

un setTrigger, de todos modos 00:48:29

a ver, una cosa, setBull 00:48:31

setFlow 00:48:32

setInteger, sí, vale, pues 00:48:33

setTrigger, y aquí lo tenemos 00:48:36

cuando nos ponemos encima dice 00:48:39

fija el valor del trigger 00:48:40

vale, pues vale 00:48:43

cuando nos ponemos aquí 00:48:44

si yo le digo que 00:48:46

al darle a la barra espaciadora el trigger que lance 00:48:48

sea el que yo he llamado salto 00:48:50

ya deja de haber estos 00:48:52

fallitos y vamos a ver 00:48:53

ya directamente sin hacer nada más 00:48:57

que yo cuando arranque el juego 00:48:59

y esté en la 00:49:00

pestaña game 00:49:02

para que se reaccione 00:49:03

yo cuando le dé a la barra espaciadora, fijaos 00:49:06

y se puede ir viendo en vivo 00:49:08

y ojo también, para que se vean 00:49:09

estas barras en reproducción y el animator 00:49:12

etcétera, tenéis que tener seleccionado el objeto 00:49:14

Que pueda haber varios objetos con Animator 00:49:16

No solo por reproducir el juego, aquí se va a ver 00:49:18

Seleccionar ese objeto 00:49:20

Cuando yo le dé a la barra espaciadora 00:49:21

Fijaos aquí, le doy 00:49:24

Y se ha lanzado 00:49:25

Como no se está ejecutando nada, se queda ahí 00:49:27

Pero en cuanto se ejecutara lo que nos interesa 00:49:29

Pues volvería a su estado original 00:49:31

Fijaos que yo 00:49:35

Gracias al código, ahora he cambiado 00:49:36

Algo, un parámetro 00:49:37

Y hay un parámetro aquí, que lo bueno 00:49:39

Es que como parámetro que hemos dicho 00:49:42

Se puede meter en condiciones 00:49:43

cuando yo ahora le di, bueno voy a borrar 00:49:45

el otro que había puesto que estaba vacío 00:49:47

cuando le di añadir una condición 00:49:49

ahora mismo solo aparece salto, no hay más 00:49:51

si hubiera más podría seleccionar más 00:49:53

y fijaos que en un trigger no hay nada más 00:49:55

es, le has dado a que 00:49:57

se ejecute, vale 00:49:59

pues fijaos ahora, si yo veo 00:50:01

aquí el muñeco que está 00:50:03

en 00:50:05

perpetuo 00:50:07

perpetua repetición 00:50:08

del idle y en cuanto yo 00:50:12

de A la barra espaciadora 00:50:13

fijaos como va a pasar al otro porque se cumple 00:50:15

la condición 00:50:17

¿vale? y ha vuelto al otro 00:50:18

porque como aquí no hay condición 00:50:21

en cuanto se ejecuta una vez, vuelve 00:50:23

al anterior y además no está en bucle el salto 00:50:25

¿vale? 00:50:27

con esto lo que podemos ir haciendo es 00:50:29

ir, pues eso 00:50:31

jugando con los parámetros 00:50:33

que nos interesa 00:50:35

la gracia de esto es que el set trigger 00:50:36

es el más básico, pero si por ejemplo 00:50:39

yo le digo 00:50:41

que esto del salto 00:50:43

se dé cuando 00:50:45

salto, claro, aquí habría que poner 00:50:46

un parámetro, voy a decirle que ahora 00:50:49

haya un parámetro que sea de tipo 00:50:51

float, que va a ser 00:50:53

salto f por float 00:50:55

¿vale? y por defecto 00:50:57

aparece cero, aquí podemos cambiar el valor 00:50:59

pero bueno, lo que queremos es cambiar este valor 00:51:01

por código realmente 00:51:03

entonces, cuando nos 00:51:04

ponemos aquí yo puedo decir que el valor 00:51:07

¿vale? y bueno, la diferencia con el 00:51:09

trigger si empezamos a escribir aquí el set float y nos ponemos aquí encima vais 00:51:11

a ver que aquí pide dos valores y de hecho hay tres sobrecargas podríamos 00:51:16

mirar más pero por defecto lo que nos pide un set float es 00:51:20

el nombre de ese parámetro y el valor que pasamos a ese parámetro y lo podemos 00:51:24

ir actualizando en todo momento vale por tanto si yo por ejemplo en este set float 00:51:30

yo le digo que este a lo que va a tocar es a el parámetro tipo float que se 00:51:35

llamado salto F, ¿vale? Y luego por coma, el segundo argumento es un valor, ¿vale? 00:51:41

Si yo por defecto le digo que ponga 10, ¿vale? Y guardo, ahora mismo estoy diciendo 00:51:48

cuando pulse la barra espaciadora me pones en este parámetro de tipo float 00:51:54

llamado salto F un valor de 10, ¿vale? Pues entonces yo ejecuto y vais a ver 00:51:58

que cuando le dé a la barra espaciadora se pone 10. Ahora mismo no tiene más repercusión 00:52:06

Más allá de que ponga aquí 10, porque no hay ninguna condición que pida eso. 00:52:10

Pero para empezar ya podemos incorporar la otra condición, ¿vale? 00:52:16

Salto F y aquí sí que ya podemos decir que el valor sea mayor o menor a un número. 00:52:20

O, bueno, pues que, por ejemplo, y podemos ir incorporando varios, ¿vale? 00:52:26

Que salto F, que sea mayor, que haya varios floats aquí, por ejemplo, con distintos valores. 00:52:35

Y este sea vertical. Y entonces, vertical podemos decir que si salto F es mayor de 0 y vertical menor de 10, yo que sé, por decir cosas, se cumple esta condición y entonces se pasa de un elemento a otro. 00:52:40

Entonces, esta es la base para ir generando estas transiciones 00:52:56

Como os he dicho, ahora voy al que ya está hecho para ir más rápido 00:53:05

Pero necesito que me digáis que la idea más o menos está clara de funcionamiento 00:53:07

Luego, evidentemente, seguir pensando qué distintas animaciones hay 00:53:14

Cómo se tienen que pasar entre unas a otras 00:53:18

Si a lo mejor nos interesa ir de esta a esta y luego a la otra que os he dicho o no 00:53:20

¿vale? y luego además 00:53:25

bueno, hay dos otros elementos 00:53:27

que os quiero indicar ahora 00:53:29

que es, que estos claro 00:53:31

van siguiendo un orden lógico, empieza según se entra 00:53:33

al nivel, se va a este y según 00:53:35

se cumplen condiciones va de uno a otro 00:53:37

siguiendo las flechas ¿vale? porque 00:53:39

es importante, si yo aquí 00:53:41

añado otra animación 00:53:42

bueno, esa justo 00:53:45

bueno, da igual, esta y esta 00:53:47

¿vale? si yo pongo 00:53:49

esto y pongo 00:53:51

esto, ¿vale? Para que veáis 00:53:53

tal. Por mucho que parezca 00:53:55

que aquí está unido y va de 00:53:57

AIDELTUTORIA a 00:53:59

ROBOTWALK, ¿vale? Estoy poniendo 00:54:01

cualquiera de ejemplo. 00:54:03

Para que se llegue de esta a esta, tal y como está ahora 00:54:05

configurado, tendría que ir pasando por todas estas 00:54:07

y cumpliéndose todas las condiciones, ¿vale? 00:54:09

Que en ocasiones también es 00:54:11

poner otra condición aquí, otra transición, 00:54:12

perdonad, y si se da esta condición 00:54:15

hará este paso 00:54:17

y si se cumple esta, se hará este otro. 00:54:18

¿Vale? Y luego hay otra 00:54:22

cosa que es, imaginaos que estáis en un juego y 00:54:23

queréis que cuando orde una bala 00:54:25

pues el personaje se muera 00:54:27

haga la animación de morir, claro 00:54:29

no podemos ir previendo que 00:54:31

desde cualquiera de las situaciones de movimiento 00:54:33

que tenga el juego se muera 00:54:35

entonces aquí hay otro nodo 00:54:37

especial, este de exit 00:54:39

la verdad es que no, bueno es por si 00:54:41

se quiere salir del controller, si no me equivoco 00:54:43

la verdad es que no lo sé 00:54:44

muy bien como decir 00:54:46

la funcionalidad no la tengo muy clara 00:54:48

pero sí que 00:54:51

Está este de, desde cualquier estado puedo saltar al que una con este any state, ¿vale? 00:54:53

Entonces, aunque estemos aquí con esta sucesión de nodos, ¿vale? 00:54:58

Incluso se puede poner más de uno, ¿eh? 00:55:04

Se pueden poner dos independientes. 00:55:06

Si en algún momento hay una condición que se cumple, ¿vale? 00:55:09

Da igual en la que estemos de la secuencia lógica que hemos ido estableciendo aquí, ¿vale? 00:55:13

Que si se da esta condición va a saltar de esa a la que pongamos aquí, por ejemplo para muerte, da igual que estemos saltando, que estemos andando, que estemos bailando, yo que sé, lo que sea, que si se cumple la condición que esté establecida de any state se ejecuta, ¿vale? Eso es importante porque a veces si no se hacen unos líos increíbles cuando se puede recurrir a este nodo, ¿vale? 00:55:18

Y otro parámetro importante es este del hash exit time, que por defecto viene marcado, que significa que a veces podemos tener animaciones, por poder, se puede de 20 segundos, ¿vale? Pero a lo mejor en mitad de esa animación de ir andando, porque es muy larga, el paso es muy largo, yo qué sé, dura mucho, en cuanto yo le dé a la barra espaciadora, quiero que salte, no que acabe toda la animación, que es lo que hace por defecto con esto de hash exit time, ¿vale? 00:55:40

Hace toda la animación y luego ya pasa a la siguiente 00:56:08

Cuando se pasa a la siguiente, claro 00:56:11

Si no, es un bucle, recordad 00:56:13

Si yo desactivo esto 00:56:14

En cuanto, da igual en qué momento 00:56:16

De la animación me encuentre, va a hacer 00:56:18

Si se cumple la condición, va a pasar a la siguiente 00:56:20

¿Vale? Ahora mismo esta es corta 00:56:22

Pero en cuanto yo pulse 00:56:24

Bueno, ahora es que justo he hecho esto de la prueba 00:56:26

De que ponga 10, pero si tuviera lo del trigger 00:56:28

Lo pongo en un segundo 00:56:31

¿Vale? Set trigger 00:56:31

Set trigger 00:56:35

Salto, y este no tiene 00:56:37

segundo parámetro, guardo 00:56:39

y ahora mismo la condición es 00:56:41

vale, ojo, estoy haciéndolo 00:56:44

todo también para que veáis la secuencia 00:56:45

de lo que hay que ir comprobando y ahora con salto 00:56:47

se 00:56:50

se pasaría, se cumpliría 00:56:50

esta condición, si yo además 00:56:54

quiero, para que lo veamos mejor 00:56:55

quiero alargar esta animación 00:56:57

le doy doble clic a la animación 00:56:59

al pulsar el estado 00:57:01

y le doy al objeto y voy a decir 00:57:03

mira, pues mientras está en 00:57:06

idle voy a hacer que esta animación dure mucho más la voy a alargar vale pues ahora dura 00:57:07

del orden de dos minutos parece vale entonces ahora cuando yo reproduzco dos minutos dos 00:57:14

segundos pero más larga ahora en cuanto se cumpliera esta condición de salto que la voy 00:57:24

a cumplir en cuanto de la barra espaciadora me voy a esperar que está aquí al principio le doy 00:57:30

y veis que ha pasado vale si esta transición tuviera has exit time vale lo vuelvo a poner 00:57:33

aunque yo le dé al salto hasta que no acabe vale bueno lo vuelvo a poner que nos ha visto bien 00:57:39

también dependiendo de cuánto de al final y al principio puede hacerlo vale pero si le doy veis 00:57:47

que le dado y hasta que no vale bueno no lo veis pero le voy a dar según está al comienzo de la 00:57:51

barra vale se hace un bucle y le doy aunque le haya dado hasta que no está acabando vale y se 00:57:55

cumple este periodo de transición para que haya una pequeña transición, no pasa al otro. Eso también 00:58:03

es importante. Entonces, a menos que me digáis que hay algo que queráis que veamos de esto de ahora 00:58:08

mismo, voy a desactivar este robot y activo el otro. Lo tengo aquí. ¿Qué tal? Hasta aquí. Más o menos es lo que pone 00:58:14

en el tema, creo. Tampoco lo que está en el vídeo de Álvaro. Vale, pues vamos a ello. Aquí tengo 00:58:26

varios estados como podéis ver a ver cómo podemos hacer para que lo veáis lo mejor posible 00:58:33

vale que va son las distintas animaciones que se han ido estableciendo incluidas algunas que 00:58:40

he sacado de otras bueno ahora lo vamos viendo veis que algunas las tengo por aquí de prueba 00:58:48

vale estando como no están conectadas a ninguna de las operaciones ni de ni stay ni de entry pues 00:58:53

están ahí que las tengo en stand by vale pero tenemos todas estas cuando empieza tiene un 00:58:58

idle no y qué es lo que he hecho fijaos la cantidad de parámetros que tengo en este en 00:59:03

este animator controller tengo un trigger que desencadena cuando detecte lo que sea que una 00:59:09

bala lo toca que se muere pues se lanza por un trigger vale y fijaos que desde este en state 00:59:17

La condición que hay es isDead, solo es esa, como hemos hecho antes con el salto. Hay una variable de tipo, entiendo que será float, esto es algo que nunca sé por qué no lo hacen, de poner aquí si es float o int para tenerlo claro. 00:59:22

Pero bueno, lo normal, aunque aquí están los íntegros, es usar float normalmente. Vale, pues aquí tenemos un float que se llama desplazamiento h, ¿vale? Que ahora veremos, lo voy a unir en todo momento con el axis horizontal de mi mando, del teclado o de lo que sea. 00:59:40

Y en todo momento va a estar definiendo un valor. Si el valor es mayor que 0.1, significa que hay movimiento, que yo quiero que se mueva el personaje. Por tanto, pasará del idle, por ejemplo, aquí al de caminado. 00:59:56

¿vale? que yo quiero 01:00:10

que vaya 01:00:13

a ver, al sprint 01:00:14

pues primero tiene que pasar 01:00:17

es decir, no quiero que pase directamente 01:00:19

de Robot Idle 01:00:21

al sprint de correr rápido 01:00:22

entonces tiene que pasar por el walk, igual el paso 01:00:24

es inmediato, es súper rápido 01:00:27

pero si aquí se cumple esta 01:00:29

condición de que el run 01:00:30

está activo, ¿vale? porque es una 01:00:32

booleana, entonces pasará 01:00:35

a Robot Sprint 01:00:37

hay otra para agacharse 01:00:38

que es otra booleana, otra que detecta 01:00:41

en todo momento si está o no está posada 01:00:43

en el suelo, por ejemplo para permitir que haya 01:00:45

un salto, si no está posada en el suelo 01:00:47

no va a cumplir 01:00:49

la condición de que se pueda impulsar para hacer un salto 01:00:51

a menos que quisiéramos hacer dobles 01:00:53

saltos y hubiera que complicar 01:00:55

un poquito 01:00:57

las operaciones 01:00:57

entonces yo si ahora mismo me meto 01:01:00

en este robot y en su código 01:01:03

que lo tengo por acá 01:01:04

vale 01:01:05

Pues vamos a ir rápido viendo un poco la lógica. Son códigos que hay que sentarse a pensar todo lo que se va necesitando, pero dos consejos previos. Por un lado, recordad que podemos ir agrupando cada tipo de acción en un método que creemos nosotros. 01:01:08

Este girar, este flip, yo he ido generando uno por cada operación que quiero que haga. Y más o menos deberían ir conectados a los distintos estados de animación. Uno que sirva para correr. 01:01:26

Y aquí está todo el rato el update, fotograma tras fotograma, viendo a ver si lo aplica o no. Habrá algunos que quiero que se apliquen en el update, que son los más relacionados con cambio de posición en el sitio, que no dependen de físicas. 01:01:42

Por ejemplo, agacharse. El personaje no se está agachando como tal, es que la animación va a ser la de agachar, recordad lo que hemos dicho. Y aparte también se cambiarán las dimensiones del boss collider, por ejemplo. Entonces ahí sí que no me importa que la detección se haga, la ejecución se haga en el update en cuanto se pueda, lo más rápido posible. 01:02:01

Y luego hay otras que tengo aquí en el Fixed Update, que son las más relacionadas con físicas, que es mover en horizontal y el mover en vertical, que es saltar. Entonces, todo ello, como ya hemos hecho en alguna otra ocasión, en base, por ejemplo, a este GetAxis que estamos capturando en desplazamiento X. 01:02:19

Hemos creado una variable de tipo float global al comienzo y con esto podremos ir también estableciendo valores, cambiando los valores de este float. 01:02:38

Entonces, vamos a ver poco a poco cómo va esto así de manera rápida. 01:02:56

lo dicho, esto 01:03:01

lo veis aquí y ya os da una pista 01:03:05

vosotros intentad hacerlo 01:03:07

dentro de la medida posible 01:03:09

viendo lo mínimo posible este código 01:03:11

que os pongo aquí, pero 01:03:13

esto ya da una idea 01:03:14

que esto además cuando lo hice 01:03:16

o cuando se hizo 01:03:19

no salió de primera, se van añadiendo más variables 01:03:20

globales a medida que se van necesitando 01:03:23

pero es importante tener 01:03:25

por ejemplo una variable alive 01:03:27

o vivo 01:03:28

Para ir determinando 01:03:30

Si el juego ha acabado 01:03:33

Y recarga el nivel, por ejemplo 01:03:34

Y lanza la animación de muerte o vida 01:03:35

¿Vale? Vamos, más bien la de muerte 01:03:38

Porque la de vida es cuando recarga 01:03:40

Ya debería estar 01:03:42

Esta booleana, que vamos a conectar mucho con el parámetro 01:03:43

De East Grounded para detectar que están en el suelo 01:03:46

Este estoy saltando, que son booleanas 01:03:48

Y veis que básicamente 01:03:50

Hay muchas que estas booleanas 01:03:51

Pues tienen que ver con agachado 01:03:54

Pues es esta misma de crouch 01:03:56

Pero ojo, no es lo mismo la variable agachado que el parámetro crouch o agachado, ¿vale? 01:03:57

Entonces aquí se van, pues como hemos venido haciendo, diciendo la fuerza de salto es 60 para multiplicarlo por el salto 01:04:03

El float que hemos creado para el desplazamiento que recoge el axis 01:04:10

La velocidad máxima por si queremos limitarla en algún momento o marcarla si damos a cierta tecla que coja velocidad máxima, ¿vale? 01:04:14

Pues aquí son los ingredientes que luego vamos a ir usando en el resto de situaciones 01:04:23

Al arrancar el juego, como suele pasar, toda variable que se base en un componente 01:04:28

Como cambiar el Box Collider, ¿veis? 01:04:34

Box Collider 2D 01:04:37

Pues con esto vamos a acceder al componente Box Collider que tenemos aplicado en este personaje 01:04:38

El Animator, como hemos hecho, también lo hemos capturado 01:04:45

Y ya las condiciones por defecto son que por defecto el personaje tiene que permanecer vivo. 01:04:50

Le ponemos una velocidad máxima, que podemos usar más tarde. 01:04:57

Por defecto también ponemos que no es grounded, porque básicamente el personaje no está tocando el suelo. 01:05:00

Lo ponemos así un poco elevado y cuando baje y toque un collider con otro collider, 01:05:07

ya sabemos usar on collision enter, on collision tal, el on trigger enter, 01:05:13

pues podemos cambiar que ese isGrounded, que por defecto es falso, pasa a ser verdadero, ¿no? Por ejemplo, si yo voy más abajo, en algún momento, aquí he dicho que cuando haya un collisionEnter, ¿vale? 01:05:19

con, en este caso, el concepto de layer y de tag que tenemos aquí. 01:05:35

También son importantes ya ir poniendo en juego porque el personaje puede ir tocando un tipo de suelo, 01:05:43

puede ir tocando otro y con estos layers y tags, como pone en el tema, podemos ir definiendo 01:05:47

que se activen o no se activen cosas según las condiciones. 01:05:52

Por ejemplo, aquí el personaje va a poner que isGrounded, según este código que tenemos aquí, 01:05:55

si el objeto 01:06:00

con el que colisiona 01:06:03

creo que ya os comenté que 01:06:04

este parámetro que tenemos 01:06:07

después de los onCollisionEnter o los onTriggerEnter 01:06:09

que también veis que son 01:06:12

tipo 2D 01:06:13

también tienen sus propios 01:06:15

sus propias versiones 01:06:17

si 01:06:20

ese objeto con el que colisiona 01:06:21

está en la layer 7, es decir 01:06:23

si por ejemplo el suelo 01:06:25

está en la layer 7 01:06:26

en ese caso sí se da la condición, ¿vale? Entonces, si este personaje, ¿vale? Porque estoy en el player manager aplicado al robot, si este objeto choca con un objeto que está en la layer 7, que yo he puesto que se llame suelo, pues is grounded de pronto is true, ¿vale? Con lo que significa que todas las condiciones de salto, por ejemplo, ahora vuelvo a donde estábamos, de salto, va a pedir que esté grounded. 01:06:29

Si esta no se cumple, pues no va a saltar, no se va a aplicar ni la fuerza, ni se va a desencadenar la animación, ese trigger para el salto. ¿Vale? Veis que aquí ya se van combinando muchas condiciones, porque si está mirando hacia un lado y le doy a la tecla control y además venía de la animación de la que fuera, entonces ya sí puedo cambiar a la otra, pero si no, a veces no me va a interesar. 01:06:55

¿Vale? Fijaos que ya en estos paréntesis cada vez hay más concatenaciones de, con estos síes, recordad, o con los de O, ¿vale? Que eran las dos, estas dos líneas verticales, ¿vale? Pero bueno, vamos con los is, se van estableciendo las condiciones. 01:07:23

entonces, vamos aquí 01:07:41

donde estábamos 01:07:44

aquí, pues 01:07:45

no solo es que esté grounded, sino que 01:07:49

además, dentro de los parámetros 01:07:51

el de is grounded va a estar en true 01:07:54

por eso vais a ver que según se lanza el juego 01:07:55

y de hecho voy a subir un poco más 01:07:58

al personaje 01:07:59

está en false 01:08:00

y cuando toque el suelo se va a poner 01:08:03

vais a ver en vivo que se va a poner 01:08:05

como true 01:08:08

ala, ha tocado el suelo y mira, ahí está 01:08:08

¿sí? 01:08:11

Entonces, aquí en vivo podemos ir viendo que las condiciones se cumplen o no. Incluso si nos interesara un momento, podemos aquí marcarlas o no marcarlas, ¿vale? Para hacer pruebas. Yo, por ejemplo, aquí si yo pongo 10, ¿vale? A ver, lo que pasa es que en todo momento me estará recalculando por otro lado que tiene que poner 0, ¿vale? 01:08:13

Pero se podría incluso ir testeando, igual que hacíamos en tiempo de ejecución aquí de ir cambiando los valores, ¿vale? 01:08:31

Se pueden ir aquí cambiando también los valores de los parámetros. 01:08:38

Pero eso, ahora mismo tenemos aquí que isGrounded es true, por eso se ha puesto como marcado. 01:08:43

Que la booleana de estoy saltando es falsa, porque todavía no estoy saltando. 01:08:51

Cuando le dé a saltar, pues a mí me puede interesar en algún momento crear una booleana, ¿no? 01:08:54

Pero este en collision enter, veis que hay una condición de si la otra capa con la que ha colisionado es de la layer 7. Pero a lo mejor si yo quiero que la colisión se haga con, por ejemplo, esta que tiene tag plataforma 1. 01:08:58

Si yo voy aquí al juego a estas plataformas que tengo móviles, fijaos que si es Layer 7, que lo es, va a permitir que el Is Grounded se detecte, se active, etc. para poder saltar desde esa plataforma. 01:09:17

Y luego, aparte, hay otra condición que he puesto aquí, que se aplicará solo si el suelo tiene este tag de plataforma móvil 1, ¿vale? Que las blancas, por ejemplo, fijaos que no lo tiene, pero esta sí, cuando caiga, cuando esté colisionando con una de este tipo, os lo pone el tema, para que el personaje se mueva con esa plataforma, que no está animada por física, sino que está animada con animación. 01:09:33

Eso también quiero que lo veamos ahora, ¿vale? Pues que lo adopte como padre y entonces, al ser, digamos, el robot hijo en la jerarquía de esa plataforma, se va a mover con esa plataforma hasta que saltemos o salgamos de esa colisión, ¿vale? 01:09:59

Que por eso aquí hay un onCollisionExit que hace las operaciones contrarias, básicamente. Tanto la condición de salto la revierte como la de que deje de ser padre, bueno, mejor dicho, que deje de ser hijo de esa plataforma. 01:10:15

Por eso si os fijáis, por ejemplo, cuando yo, fijaos en la jerarquía del robot, cuando el robot pise la plataforma, una plataforma como esta, que sí que tiene ese tag, cuando lo pise vais a ver que la jerarquía se ha puesto como hija de una plataforma. 01:10:33

A ver, que le van a matar enseguida, pero estaba por ahí. A ver, vuelvo a hacerlo. ¿Vale? Perdonad que es que esta plataforma está aquí. Vale, pues se va a hacer hija de esta plataforma. Entonces yo ando y cuando me poso en ella, fijaos que se mete aquí como hija y cuando salto, vuelve el robot a estar fuera. Se ha puesto aquí abajo porque no se ha colocado igual, pero vuelve a estar fuera. ¿Vale? 01:11:00

Entonces con eso, por ejemplo, podemos ir adoptando estos comportamientos de, pues eso, ahora ha desaparecido y vuelve a estar de hija de la plataforma. Salto y deja de estar de hija de la plataforma, ¿vale? 01:11:27

Bueno, esto me sirve para que sepáis lo de los tags y los layers que existen y se pueden usar, que los onCollision y los onTrigger también tienen su versión 2D, ¿vale? Y también el tipo de variable que se usa. 01:11:40

Y otra cosa importante del panel animation. A diferencia del personaje que se va a ir animando en base a los distintos fotogramas que hemos incluido desde la hoja de sprites, que es lo que hemos hecho hasta ahora, 01:11:53

también las animaciones os he dicho que pueden ser 01:12:14

de tipo kinemático 01:12:18

y cuando digo que es de tipo kinemático 01:12:19

es que si yo me meto en una 01:12:21

de estas plataformas y miro 01:12:24

su animator controller 01:12:25

solo tiene un estado 01:12:27

que es, si me meto en la animación 01:12:28

es que yo he cogido esa 01:12:31

plataforma, me he metido en el 01:12:33

panel de animation 01:12:35

y le he dicho, quiero crear 01:12:36

una animación para 01:12:39

esa plataforma 01:12:41

Por ejemplo, selecciono esa plataforma y veis que aquí está. 01:12:43

Y aquí no hay ningún tipo de sprite. 01:12:47

Aquí lo que hay es que podemos ir añadiendo propiedades de los distintos componentes y animarlos en el tiempo. 01:12:51

La posición, la rotación, la escala. 01:12:57

Y yo aquí lo que he hecho es la posición en X, cambiarla de izquierda a derecha y hago un bucle. 01:12:59

El primer fotograma y el último son el mismo. 01:13:06

y veis, voy a ampliar aquí, que básicamente lo que he conseguido es que poniendo esta animación en bucle, 01:13:08

además, si la busco por ahí, está con el loop activado, he hecho que esta plataforma esté de izquierda a derecha todo el rato. 01:13:16

Este movimiento es kinemático, es decir, no es en base a físicas, es porque estamos cambiando, 01:13:25

y lo podéis ver aquí claramente, estamos cambiando la posición en el transform. 01:13:31

Por eso hacemos lo de que cuando el personaje pise esa plataforma se mueva con la plataforma, porque no se está moviendo por físicas y no hay nada arrastrando otra cosa. Hay que hacerle hijo para que se asocien sus valores de transform, que los herede de su padre. Por eso hay que hacer esa operación. 01:13:34

Si esta plataforma la moviéramos, también se podría, mediante velocity sería más complejo, se moviera primero hacia la derecha, frenara y luego otra fuerza hacia la izquierda y que no tenga gravedad y no se caiga, que se mantenga fija siempre en el mismo eje Y, en la posición de Y, ahí sí que habría una cierta, no completa, una cierta inencia del personaje que se vería arrastrado. 01:13:54

Pero es verdad que sería cierta porque tampoco tendría por qué estar completamente anclado. Por eso, dependiendo de si va por físicas o va por kinemática, hay que hacer estas operaciones. 01:14:16

Pero que las animaciones, igual que las metemos aquí, también pueden ser animaciones que sí se mueven, por ejemplo, en el espacio o que rotan. Voy a hacer una cosa un poco así extraña, que es, yo que sé, voy a decirle que vaya rotando también. 01:14:30

y yo le digo, vale, aquí y que cuando esté en este punto 01:14:48

pues que rote en Y 01:14:51

despliego aquí y le digo 01:14:53

quiero que esto rote en Y 01:14:57

pues yo que sé, bueno, en Z mejor dicho 01:15:00

que rote hasta aquí, ¿vale? y ahí he añadido un fotograma 01:15:03

¿vale? pues ahora cuando 01:15:07

reproduzcamos el juego 01:15:09

como esa animación la he cambiado, vais a ver que tiene esa interpolación 01:15:10

Ahora el juego es bastante más complicado 01:15:16

Pero eso, que sepáis que las animaciones también se pueden 01:15:18

Se pueden 01:15:20

Realizar en base a 01:15:22

Animar parámetros, incluso se puede animar 01:15:24

Que el boss collider cambie de 01:15:27

Posición o que el sprite 01:15:29

El color vaya siendo de uno u otro 01:15:31

¿Vale? Todas esas animaciones se guardan 01:15:33

En clips de animación y luego 01:15:35

En el animator controller 01:15:37

Aquí solo hay uno porque queremos que este se haga en bucle 01:15:39

Bueno, pues podemos ir también 01:15:41

Pasando de uno a otro 01:15:42

¿Vale? 01:15:44

Y luego, simplemente para que lo sepáis, si marcáis este botoncito rojo de auto keyframing, si lo activamos en rojo, todo lo que vayamos cambiando, que antes había que ir aquí moviendo los parámetros y creando el keyframe, en cuanto se cambie un valor, veis que va a ir añadiendo los fotogramas según haga los cambios. 01:15:46

Esto puede ser muy cómodo o muy peligroso. Entonces ahora vais a ver que he cambiado así cositas y cuando reproduzco el juego, cuando vea la animación, para empezar la escala, por ejemplo, que la tengo aquí, se hace grande, se queda grande y luego se vuelve a reproducir y se hace pequeña. 01:16:10

Por eso no es suave el paso de grande a pequeño, ¿vale? Pero bueno, esto es como una animación que hacéis en 3D o en otros casos, pues que sepáis que también se puede aplicar a objetos. 01:16:28

Y en el caso de las plataformas o de unos pinchos que salen o un enemigo que está botando todo el rato a lo mejor y no queremos que sea por física, pues se puede hacer con este tipo de animaciones, ¿vale? 01:16:40

Entonces, voy a explicar una cosa más, así rápida, y vamos a dudas concretas, y si no, sigo explicando, ¿vale? Pero quiero una siguiente cosa, que es básicamente el movimiento, ¿vale? Que es lo que me han dicho antes. Pues yo en todo momento sé que voy a estar calculando en esta variable, desplazamiento x, bueno, la que llaman así, con el que taxis el valor, fotograma, fotograma, ¿vale? Y esto va a ir del menos uno al uno, si recordamos, pasando por el cero. 01:16:51

A diferencia del salto, que es pulsar una tecla, nos interesa en el desplazamiento que sean positivos o negativos, ¿no? Entonces vamos a estar en todo momento, ¿vale? Y como sabemos que la animación horizontal lo vamos a hacer por físicas, por eso lo meto en el Fixed Update, si no podría estar en el Update. 01:17:21

Yo he creado este método que se llama mover. ¿Y qué he hecho en mover? Pues decirle que en vez de usar el Digibody, el AddForce, que es simplemente para añadir fuerzas en una dirección u otra, está el parámetro de Velocity, la propiedad de Velocity. 01:17:41

Y Velocity es como mover, digamos, de manera kinemática, pero ampliando las fuerzas. Es decir, es un movimiento inmediato, hacia izquierda, hacia derecha, según la Velocity. 01:18:08

Entonces, con esto, la velocidad de este objeto, de este RigidBody, lo podemos ir variando, por ejemplo, con este valor, que va a ir variando la dirección de ese movimiento físico según lo que vayamos pulsando en las teclas, en este axis. 01:18:20

y además tiene dos dimensiones, la de x que multiplicará ese desplazamiento que conseguimos con el joystick o las teclas 01:18:38

y lo multiplicamos por este más speed, como está en el fix update no hay que hacer un time delta time, 01:18:50

ya está ejecutándose en tiempos de físicas y en el eje y no queremos que haya ninguna variación. 01:18:55

Esto también lo vimos ya si no me equivoco el otro día con la bola, pero cuando ponemos que un valor de varias dimensiones 01:19:02

Que coja el de uno de los ejes 01:19:08

Y está bien puesto en su eje 01:19:10

Como esta es la coma del eje X 01:19:12

De la dimensión X del vector 01:19:14

Y este es el Y 01:19:16

Esto simplemente hereda el movimiento que sea 01:19:17

No le decimos que sea cero 01:19:21

Y se estanca en cero la velocidad 01:19:23

Es que vaya heredando la vertical 01:19:24

Por ejemplo que apliquemos con el salto 01:19:26

Y con esto conseguimos que el personaje 01:19:29

Se mueva de izquierda a derecha 01:19:31

En horizontal 01:19:32

Más la gravedad que también le está aplicando el RigidBody 01:19:33

Y luego, por otro lado, ¿vale? Y aquí está el juego, aparte del movimiento en sí del GameObject, hay que hacer la apariencia de que este parámetro se está animando, ¿vale? 01:19:37

¿Y cómo lo vamos a conseguir? Tenemos aquí un parámetro, si voy a Robot, ¿vale? Tenemos un parámetro que hemos dicho de tipo Flash que se llama DesplazarH, ¿vale? 01:19:51

Con la D mayúscula, ojo, hay que ponerlo respetando las mayúsculas. 01:20:02

Entonces, lo que voy a decir es que este desplazamiento en H sea en función a lo que tengamos aquí, al valor de desplazamiento X. 01:20:09

Ahora os explico por qué pongo más código. 01:20:19

Pero básicamente es eso. Aquí estamos diciendo, y lo voy a hacer en vivo, 01:20:23

A medida que vamos pulsando la flecha izquierda y derecha, porque es donde está configurado ese axis de desplazamiento horizontal, vais a ir fijándoos que cambia este valor de 1, si paro 0, de 0 a 1. 01:20:26

Y no hay menos 1. ¿Por qué? Porque, como hemos dicho antes, las condiciones pueden ser mayor o menor. Y aquí lo que queremos es que haya algún tipo de desplazamiento. El lado, ahora vemos cómo lo definimos, el lado lo definimos después. 01:20:43

Pero lo que queremos es que haya, que se detecte que ese axis está siendo diferente a cero. Entonces, ¿qué se hace? Que con esta conversión a absoluto del valor, con esta operación de conviérteme este valor que aquí hay dentro a un valor absoluto, lo que hace es que no hay valor en negativo, siempre lo convierte a positivo. 01:20:58

Entonces da igual que estemos dando a un lado del axis o a otro, que aunque para la velocidad, el velocity, perdonad, físico, sí que está influyendo que vaya izquierda a derecha, ¿vale? Para decir que se active la animación de RobotWalk, ¿vale? De que está caminando, ahí solo con saber que está siendo diferente a cero, ¿vale? Pues ya nos valdría. 01:21:18

porque si contáramos con que cuando fuera menos uno 01:21:42

porque le demos a la izquierda también tuviera que hacerse esa condición 01:21:46

tendríamos que poner más condiciones y sería un poco jaleo 01:21:49

porque además una se puede contradecir con otra 01:21:52

y sería un poco complicado 01:21:55

es posible, y esto también me sirve para contaros una cosa 01:21:57

si creamos diferentes transiciones 01:22:02

dentro de una misma 01:22:04

es decir, que en un mismo flujo, en un mismo paso de un estado a otro 01:22:07

puedo ver que una condición sea, cuando desplazamiento H sea mayor de 0,1, o hacer una transición y si volvemos a hacer el mismo recorrido vais a ver que aquí se ponen tres triangulitos diciendo 01:22:11

aquí hay dos condiciones, que son estas, ¿vale? Hay dos posibles y cada una, según clicamos, ¿vale? Transiciones y hay dos y se pueden incluso incorporar más, ¿eh? 01:22:24

Tres. Y voy aquí y hay tres. Y cada uno, ¿vale? Son condiciones independientes. Yo aquí también, si no hiciera eso del valor absoluto, podría añadir otra y decirle desplazamiento h que sea menor a menos 0,1. Más, no, menos. ¿Vale? Y entonces así sí que se podría conseguir. 01:22:35

Porque si se cumple una, no se cumple la otra. Con que se cumpla una ya se daría esta transición. Son independientes. Por poder se podría, pero también servía un poco para contar esto que a veces nos puede interesar que los valores negativos no lo hayan. 01:22:55

El problema que hay, esta animación de Robot Walk, esta de aquí, vamos aquí al robot, es en una dirección solo. 01:23:11

Espera, que estoy aquí abriendo cosas y no tiene sentido. 01:23:23

Cuando empieza a caminar es hacia la derecha, que es hacia donde mira. 01:23:27

Ahora mismo, como os acabo de decir, aquí está, con esto sí estamos consiguiendo que se mueva el objeto izquierdo a derecha. 01:23:33

Y con esto estaríamos consiguiendo que el personaje hiciera el caminado. Pero hasta aquí solo tendríamos que el personaje estaría haciendo el caminado. Aunque vaya a la izquierda, lo haría de espaldas, porque estaría mirando a la derecha. 01:23:42

Por eso hay otro parámetro, que es este, vamos, otro método, que de tanto hablar a veces ya me fundo, que está, este sí, en todo momento, en cuanto se pueda, en cuanto detecte el axis que está cambiando la dirección, 01:23:56

Otro método que es el de girar, ¿vale? Que es independiente al de mover, aunque están unidos, pero bueno 01:24:21

Que es este que si dice, si el desplazamiento X es mayor a 0, es decir, estoy dando la tecla de hacia la derecha 01:24:26

Y no está ya mirando a la derecha, haz un flip 01:24:35

Y si lo contrario, si es menor a izquierda y no, es decir, si el desplazamiento es hacia la izquierda 01:24:38

Y si está mirando hacia la derecha, ¿vale? Estos son booleanas que yo voy cambiando en todo momento, ¿vale? 01:24:45

Hace un flip. ¿Y qué es un flip? Pues otro método que he creado que en cuanto se ejecute, es decir, en cuanto en realidad se esté cambiando de dirección, ¿vale? Que, y estas líneas creo que las tenéis en el enunciado, vamos, creo no, las tenéis en el enunciado, lo que hacemos es cambiar la escala. 01:24:51

Es decir, que el desplazamiento físico va hacia la derecha o hacia la izquierda, independientemente de la escala, son las físicas del mundo, ¿vale? La animación en principio se está haciendo con el personaje hacia la derecha, que es como están diseñados los fotogramas, pero lo que sí podemos hacer es cambiar la dirección hacia la que mira al invertir la escala, ¿vale? 01:25:10

Entonces vais a ver que cuando yo, voy a seleccionar aquí el robot, cuando yo voy a la izquierda va a cambiar, ¿vale? Hasta ahora solo he ido hacia la derecha y el flip no se ha ejecutado, pero cuando voy a la izquierda, fijaos que se ha puesto en menos uno y lo que ha hecho es girar la imagen. 01:25:33

No es girarla, es como agrandarla hacia el otro lado y se invierte. Entonces, con este flip, aunque el personaje, los sprites, siempre están ejecutándose hacia la derecha, como se invierte, está ejecutándose hacia la derecha, pero invertido. 01:25:50

¿Vale? Cuando paro, cuando paro, es decir, cuando dejo de pulsar el desplazamiento en h, cuando es menos de 0,1, ¿vale? Cuando es 0, básicamente, paso otra vez al idle. 01:26:05

¿Qué problema había con lo de hacer las condiciones más de una y que fueran en negativo? Que realmente desplazamiento en h menor a 0,1 sería ir hacia la izquierda si no hubiéramos hecho esto del absoluto. 01:26:17

Por eso lo hemos hecho. Hay otra forma más fácil, que tiene otros problemas, de hacer esta inversión, este flip, en vez de con el método de invertir la escala, que es este que os he dicho antes, que está en el propio SpriteRenderer. 01:26:28

Si yo me metiera en el SpriteRenderer, ¿vale? Que es el SpriteRenderer. Si yo pongo aquí otra variable que se llame SpriteRenderer, ¿vale? Y la capturo como componente, etc. De hecho, mira, lo voy a hacer. SpriteRenderer, lo voy a llamar SR. 01:26:46

y aquí hago 01:27:00

sr igual a 01:27:04

este no me sale automático 01:27:06

pero get component 01:27:08

en vez de boss collider 01:27:09

quiero que sea el sprite 01:27:12

sprite 01:27:14

renderer 01:27:15

debería salir y ahí está 01:27:17

si yo en algún momento 01:27:19

dijera en vez de hacer todo esto 01:27:21

bueno habría que decir 01:27:27

que invirtiera, que cada vez que está viendo uno de los lados, aparte de mirando derecha, pues diría sr.flip en i, porque queremos que se invierta en i, que sea el inverso. 01:27:30

Es decir, hasta aquí no, que lo invierta. Sería lo mismo que hemos hecho aquí. Que el que ya tuviera lo invierta. Y esto, por ejemplo, lo puedo dejar aquí comentado. Y ahora vais a ver que el resultado debería ser el mismo. 01:27:48

¿Qué es? Que ahora conseguimos... Bueno, no sé si he guardado... Sí, sí he guardado. Y cuando yo le dé a play, ahora estamos haciendo esta inversión, ¿vale? Es decir, el personaje se está moviendo de izquierda a derecha con el velocity, independientemente de hacia dónde mire lo que es el sprite. 01:28:05

El sprite pasa al otro estado y empieza a andar, pero con esto, uy, claro, no, se me ha ido la pinza, esto es en X, y creo que ya estaría, sí, no hemos puesto flip, sí, vale, pero nada, vuelvo a recargar, vale, y fijaos que ahora lo que cambia aquí es el flip en X, cuando voy a izquierda se activa esto, cuando voy a derecha, vale, también se podría así. 01:28:22

Es otra forma, pero la otra sí que es verdad que otras operaciones que impliquen que tenga que estar mirando hacia la izquierda, si se conectan con esa inversión del menos uno, que ahora es activado, si os fijáis, también se podría conseguir. 01:28:52

Bueno, esto lo digo para que veáis también para qué sirven los... voy a deshacer esto... ¡Epa! Un segundo... Vale, ahí está. ¿Vale? 01:29:06

Dudas hasta aquí. Bueno, si os fijáis ahora, lo que hay que ir pensando es cómo se van jugando las distintas transiciones. 01:29:19

Pues hay run, cuando run es true, que básicamente yo lo he asociado a pulsar el shift izquierdo mientras yo mantengo pulsado el shift izquierdo, no mientras mantengo pulsado con el script, pero sí que es verdad que cuando pulso la tecla, por eso es el down, run in is true y este run se pone en verdadero y cuando suelto ese shift izquierdo deja de serlo. 01:29:31

Entonces, ¿qué es lo que consigo? Que si ya estoy caminando y le doy al de correr, al botón que yo tengo como de correr, pues de pronto hace la animación de correr, aparte de que le doy más velocidad, ¿vale? Sí, a ver, yo le doy aquí y cuando le doy a shift y fijaos que va a cambiar, cuando le doy, se va a poner el tick, cuando le doy a shift pasa al sprint y aparte va más rápido, por eso da esas zancadas. 01:30:00

Entonces, aparte de darle al sprint, sí que en algún punto, en correr, es raro que no esté aquí, pero aparte de cambiar a que pase al estado, al nodo de run, porque se cumple la condición, isRunning es true. 01:30:23

Y esto en algún momento hará también que se mueva más rápido. 01:30:40

Imagino. 01:30:45

Is running. 01:30:49

Pues, a ver, igual no lo configure para que vaya más... 01:30:50

Sí. 01:30:54

Ah. 01:30:55

Is running, bla, bla, bla. 01:30:58

Vale. 01:31:00

Pues en algún punto lo habré puesto, que ahora mismo no caigo, pero... 01:31:02

Voy a la tecla... 01:31:07

Bueno, esto tendría que buscarlo. 01:31:08

Pero básicamente, si pulsamos las teclas Shift, corremos, 01:31:10

IsRunningTrue, pero claro, tiene que haber más sitios con IsRunning. 01:31:14

Ah, vale, sí. 01:31:20

Aquí lo que cambio es la... 01:31:23

Lo que cambio... 01:31:29

No sé en qué punto lo estaba haciendo, pero se podría hacer básicamente aquí. 01:31:36

Vaya, aunque ahora mismo no encuentre dónde lo puse. 01:31:43

perdón, aunque no lo puse 01:31:45

aquí se puede poner mientras pulso esto 01:31:50

maxSpeed por ejemplo 01:31:51

pues sería el doble 01:31:53

pondría maxSpeed 01:31:55

por 2 01:31:57

y se movería el doble 01:31:59

en cuanto que 01:32:01

esta variable es la que hace que tenga el desplazamiento 01:32:04

ahora mismo no sé dónde lo puse 01:32:06

pero bueno, sería así de rápido 01:32:08

y cuando se deje de pulsar la tecla 01:32:10

shift izquierda 01:32:11

pues Max Speed volvería a ser su valor habitual. 01:32:13

Vale, hasta aquí ¿qué tal? 01:32:18

Es decir, lo que es el sistema de plataformas y llegar hasta el final, 01:32:20

que es lo que no es opcional, tirando de estos hilos se llegaría. 01:32:24

Sé que hay que dar vueltas, luego por supuesto también hay cosas que ya hemos heredado, 01:32:29

como el reload, que es que cuando muera por lo que sea, pues se recarga la escena, 01:32:35

o que cuando un precipicio, que hay un non-trigger que recarga la escena también, cuando el personaje, lo tengo aquí, toca con este GameObjectPrecipicio que prepara aquí, que cubre toda la base inferior, 01:32:41

Pues este Boss Collider 01:33:05

Es un East Trigger 01:33:08

Que cuando le toque otro personaje 01:33:10

Que es, que he hecho que sea 01:33:11

El que tenga el Tag Player, que el robot tiene este Tag 01:33:13

Pues recargue el nivel 01:33:16

¿Por qué hay que poner esta condición, por ejemplo, aquí? 01:33:17

Porque, claro, yo por ejemplo 01:33:21

Aunque no se muevan más cosas 01:33:22

Sí que hay unas balas 01:33:24

¿Vale? 01:33:26

Que esto ya es opcional, por lo más complejo 01:33:28

Pero os animo a que lo intentéis 01:33:30

Que si sigue la trayectoria, llegarían a tocar 01:33:31

Fijaos 01:33:34

Aunque yo las desactivo en cierto momento 01:33:35

Llegaría a tocar ese 01:33:37

Ahí habría desencadenado 01:33:39

Que se reseteara 01:33:41

Se recargara el nivel 01:33:43

Por eso hay que filtrar 01:33:45

Las balas no tienen el layer 01:33:46

El tag de player, pero el robot 01:33:48

Si nos fijamos, sí, porque se lo he puesto yo 01:33:51

¿Vale? Entonces eso sirve para ir 01:33:53

Discriminando 01:33:55

Qué desencadena o qué influencia 01:33:56

En qué 01:33:59

Vale, contadme cosas, dudas 01:34:00

¿Cómo os quedáis? 01:34:05

¿Cómo se aumenta la dimensión de la escena del juego para que sea más grande? 01:34:07

La dimensión de... es decir, si te estoy entendiendo bien, cuando creáis un juego en 2D vais a ver que viene incorporada esta opción de 2D. 01:34:13

En realidad es la misma escena 3D que hemos tenido siempre, pero básicamente cuando jugamos en 2D, aunque podemos colocar cosas en profundidad, 01:34:24

lo que va a reaccionar 01:34:35

o va a interactuar una cosa con otra 01:34:38

en el mismo nivel de profundidad 01:34:40

la dimensión es 01:34:41

por defecto ya viene todo esto 01:34:43

de grande, es decir 01:34:46

lo que es la dimensión en sí no se cambia 01:34:47

entiendo que lo que te refieres 01:34:49

es la apariencia del fondo 01:34:52

porque aquí si no hubiera este fondo 01:34:53

básicamente si yo lo desactivara 01:34:56

y yo voy poniendo aquí plataformas 01:34:57

plataformas 01:34:59

el juego empezaría en donde 01:34:59

básicamente tengamos la cámara y se vea 01:35:03

¿vale? 01:35:06

y bueno, y todo para que tenga sentido de lo que se vea 01:35:07

si queremos 01:35:10

que el fondo pues sea más 01:35:12

grande o lo ponemos más grande 01:35:14

¿vale? o otra cosa importante 01:35:15

que ahora os explico es 01:35:18

si no es tileable hay que ir diseñando 01:35:19

es decir, si es un diseño en el que 01:35:21

digamos que no se van repitiendo edificios 01:35:23

y es un diseño muy grande, hay que hacer una imagen 01:35:25

muy grande y ponerla detrás como hemos hecho aquí 01:35:27

¿sí? no hace falta 01:35:29

tampoco que esté en otra dimensión del eje Z 01:35:31

como aquí, que aquí lo hago 01:35:33

porque a mí me resultaba más fácil 01:35:35

pero en los ejemplos que os dejo 01:35:37

de la Nubis 01:35:40

que en realidad está bajado 01:35:41

de la SetStore, en alguna modificación 01:35:43

pero está ahí 01:35:45

o bueno, pues 01:35:46

es decir, en el tema 01:35:49

pone que se puede jerarquizar la profundidad 01:35:51

con los Sorting Layers 01:35:54

del Sprite Renderer, por ejemplo 01:35:55

aquí 01:35:57

si voy a... 01:35:58

Claro, es que aquí lo he metido como si fuera 01:36:00

un 3D. Es otra forma. Se pueden 01:36:02

combinar objetos 3D con el 2D 01:36:04

realmente. Ahora estamos centrándonos en el 2D 01:36:06

pero se puede. De hecho, también 01:36:08

en el tema se habla de que están los juegos 01:36:10

de apariencia 2D 01:36:12

pero que en realidad son 3Ds. Pero cuando 01:36:14

estamos en un... 01:36:16

solo con assets, con sprite 2D 01:36:18

¿vale? Están estos 01:36:20

sorting layers, ¿vale? Para ir 01:36:21

agrupando en profundidades. 01:36:24

Esto en el Anubis se ve bien si os metéis en ese proyecto. 01:36:26

Entonces, bueno, si hay otra opción, y ya que lo ha sacado, pues os lo comento. 01:36:30

Si os fijáis en las plataformas, vuelvo al modo 2D, para estar en donde nos corresponde ahora. 01:36:35

Que yo tengo plataformas que en su Sprite Renderer vais a ver que son con este modo simple, 01:36:42

que es que la imagen yo la puedo escalar y se hace más o menos grande en base a estos sprites que os he pasado. 01:36:49

pasaba este vale pues aquí básicamente pues he cogido esto y lo he hecho tan 01:36:56

grande tan pequeño como he querido con él con la herramienta del red tool que 01:37:01

es la que más sirve para escalar vale y digo quiero así que sea así de grande 01:37:05

como tampoco tiene es blanco pues deforma y no se nota vale eso por 01:37:08

ejemplo en el techo también que es un blanco pues también puede ser rojo digo 01:37:14

es un color sólido pues se mueve y listo pero otro de los que os he pasado como 01:37:19

estas cajitas tienen un patrón, si os fijáis, fijaos que tienen unos cuadraditos, entonces escalarlo se ve feo, ¿no? De hecho yo en estas últimas sí que lo he escalado y se ve feo, si os fijáis, lo he pasado por alto, pues lo he escalado y ya está, del tamaño que quiera, pero en estas plataformas de aquí, ¿vale? Y eso es porque está en el modo simple, ¿vale? Pues que yo lo hago más grande o más pequeño y se deforma, no tiene más, pero en estas de aquí, si os fijáis, ¿vale? Los cuadradicos, 01:37:25

Sí que no se han deformado en proporción y se van sumando unos a otros. Es un único. Bueno, esto también es este. Aquí es un prefab que he metido dentro el Sprite Renderer. Lo que he hecho, y hay otra opción, por si tenéis un fondo que a lo mejor es tileable, es decir, es como una secuencia de los mismos edificios que cuando acaban empiezan otra vez. 01:37:55

no tenéis que hacerlo, podéis también 01:38:19

como yo he hecho en este ejemplo, hacerlo grande y ya está 01:38:22

pero si queréis que no sea 01:38:24

super grande el fondo y se vaya tileando 01:38:26

se vayan repitiendo una y otra vez 01:38:28

hay un modo de dibujado que es este 01:38:30

de Tile, y con este 01:38:32

hay una opción aquí, si os fijáis me pongo aquí 01:38:34

que si está en simple, se deforma 01:38:36

si lo pongo en Tile 01:38:38

sale esta opción que yo, lo que se va 01:38:40

haciendo es más grande y más pequeño 01:38:42

repitiéndose, veis que es ese mismo 01:38:43

patrón de los cuadrados, una y otra 01:38:46

vez. Esta es una forma de que los 01:38:48

sprites se tileen. 01:38:50

Luego hay otros modos, como este adaptativo 01:38:52

y tal, que se ajustan de otras formas 01:38:54

para que básicamente 01:38:56

se ajusten los bordes 01:38:58

y ya a partir de ahí se vaya tileando. 01:39:00

Pero con esto podéis hacer 01:39:02

que un mismo diseño sea el tileable, 01:39:04

incluido el fondo. 01:39:06

Para que esto vaya bien, si no me equivoco, 01:39:09

aparte de 01:39:13

ponerlo en modo tile, 01:39:13

lo suyo es, para que no de problemas, 01:39:15

que el mesh type pase 01:39:17

de el que viene por defecto de tight a full red 01:39:19

porque si no me equivoco 01:39:21

cuando me meto en el objeto 01:39:23

y 01:39:25

lo pones tileado, te sale 01:39:27

este error, puede no aparecer 01:39:29

correctamente, porque no, bueno 01:39:31

un conflicto, que aún así lo hace 01:39:33

¿vale? pero sí que es verdad 01:39:35

que para que funcione de manera correcta 01:39:37

esto se pone en full rect 01:39:39

se aplica y ya está 01:39:41

y ya, pues se puede tilear 01:39:43

que ojo, que aunque se ponga en full red, si se pone en simple 01:39:45

también se puede escalar 01:39:47

el full red sobre todo es para 01:39:49

otro modo que hay que se llama slice 01:39:52

que lo que hace 01:39:54

que los botones por ejemplo 01:39:56

cuando se hacen más grandes o más pequeños 01:39:57

no se deforme el interior 01:40:00

en las interfaces 01:40:01

es un poco más allá 01:40:02

de lo que estamos viendo 01:40:06

más cosas que en 10 minutos 01:40:07

vale 01:40:11

para la entrega 01:40:13

con que hagáis una estructura de 01:40:16

plataformas, que se mueva el personaje 01:40:17

que haga las animaciones que se piden 01:40:19

que haya plataformas animadas 01:40:21

que el personaje vaya saltando 01:40:23

lo que son las torretas y tal 01:40:25

pone que es opcional 01:40:26

sí que es verdad que si lo intentáis hacer 01:40:27

de esas partes, en el enunciado 01:40:31

lo que os he dicho 01:40:33

hay un montón de código 01:40:34

para que lo vayáis 01:40:37

a ver, a medida que vais bajando 01:40:38

aquí veis que los códigos ya son bastante más largos 01:40:41

¿vale? 01:40:44

pues bueno, si os atrevéis 01:40:45

si da por ello, porque además voy explicando más cosas 01:40:47

más avanzadas, ¿vale? Pero 01:40:49

si os veis con fuerza 01:40:51

la verdad es que sería genial porque le da 01:40:53

más gracia al nivel. Pero, de momento 01:40:55

con hacer plataformas que el personaje se vaya 01:40:57

moviendo y haya teniendo esas 01:40:59

animaciones, con el 01:41:01

Animator Controller según la acción que hagamos 01:41:03

pues más o menos se cumple 01:41:05

el objetivo del tema. 01:41:07

Pues decidme, venga, a ver 01:41:12

cosas o algo que queráis que veamos en los últimos 01:41:14

minutos. Bueno, no lo he dicho 01:41:16

pero está subido 01:41:18

el simulacro de examen, ¿vale? Sí que es verdad que no quiero repasar mucho cómo es, a no ser que tengáis dudas, 01:41:20

pero bueno, sois de segundo normalmente y lo tenéis aquí, ¿vale? A menos que tengáis alguna duda concreta, 01:41:27

bueno, ya cuando acabe el curso, me refiero, cuando se suban ya todos los temas, pues hablaré un poco más 01:41:33

del examen en sí. Ahora mismo me interesa que estudiéis los temas directamente. Pero bueno, eso, que sepáis, 01:41:38

si no lo habéis visto ya, que el simulacro de examen con la estructura, aunque no están planteadas las preguntas, pero un tipo de estructura y las normas iniciales que van a tener el examen de puntuación, etc., 01:41:45

y de normas de comportamiento también en el examen, pues ya están aquí. Una de las cosas que te faltaría, imagino, que no me contesta, 01:42:01

es que estos parámetros que son float, etcétera, eso, se van actualizando con los valores de un axis, por ejemplo. 01:42:13

Entonces, en todo momento se puede ir reflejando el valor para que haga una transición u otra, ¿vale? 01:42:22

Como hemos visto con la animación izquierda-derecha. 01:42:30

El salto, si os fijáis, y así lo vemos un poco por si acaso, la sugerencia. 01:42:33

A ver, ahora contesto a lo que ha puesto la compañera. Saltar, ¿vale? Pues saltar, por ejemplo, es si le he dado a la barra espaciadora, bueno, lo primero es que en algún momento, ¿vale? Yo he definido en el update que cuando le dé a la barra espaciadora, la variable estoy saltando se vuelva true, ¿vale? 01:42:38

No estoy activando el saltar desde aquí, estoy diciendo que sea true. Y en todo momento, el fix update está activando o desactivando ese saltar. Está todo el rato mirando en saltar, a ver si estoy saltando, se ha activado ya. 01:43:06

Si estoy vivo, si además estoy grounded y no estoy agachado, que es otra de las propiedades de las variables booleanas que se van activando y desactivando, si es así, pues oye, el trigger de jump que se active y le doy esta vez sí con un add force que vaya hacia arriba con modo impulso. 01:43:24

Vale, honestamente creo que la dificultad es bastante desproporcionada con el nivel que tengo, pero aún así lo intento hacer. Sinceramente, también es verdad, ¿eh? Bueno, entiendo completamente que os sintáis así, ¿vale? En ciertos momentos del curso, ¿vale? 01:43:47

Pero todo esto, hasta que no os pongáis a hacerlo, ¿vale? Y sé que son tareas largas, pero es que hasta que no os pongáis a hacerlo y a pensarlo, por mucho temario que veáis, por muchos vídeos que veáis, por todo lo que sea, hasta que no os pongáis a hacerlo, poco a poco no vais a saber hacerlo. 01:44:03

Es decir, vais a tener las herramientas, pero hasta que no os ponéis a pensarlo, no. Porque una vez os ponéis a pensarlo, es ir creando condiciones y variables. Sí que toma tiempo, pero realmente aquí hay mucho más código, porque yo tengo más cosas de las que os pido y aquí hay mucho más scripts. 01:44:24

pero por ejemplo 01:44:42

poner los distintos 01:44:45

estados y transiciones 01:44:47

e ir pensando los distintos 01:44:48

métodos que hay 01:44:50

con las instrucciones que más o menos he seguido dando 01:44:52

creo que 01:44:55

lleva tiempo pero no es tan complicado 01:44:56

lo de las torretas por ejemplo ya tendría 01:44:58

otras migas más distintas 01:45:00

porque además se ponen en juego 01:45:02

muchos más scripts independientes y hay que conectarlos 01:45:03

pero lo que es mover el personaje 01:45:07

y hacer las plataformas, colocarlas en el 01:45:08

espacio con sus colliders 01:45:10

y que el personaje se vaya moviendo entre una y otra con las animaciones, 01:45:12

yo estoy convencido de que si os ponéis, lo sacáis. 01:45:17

Sé que lleva tiempo, pero es el nivel de plataforma más básico que podemos hacer 01:45:20

y en principio hay que aprender a hacer uno. 01:45:26

Y en el tema creo que se explica todo lo necesario. 01:45:30

Pero también os lo digo así, si me dieran esta tarea, 01:45:34

al principio, incluso 01:45:39

diciendo, yo sé hacerla, vamos 01:45:41

sé hacerla, pero 01:45:43

ya simplemente el tener que sentarme 01:45:45

a pensarlo, a desgranarlo, es un ejercicio 01:45:47

que lleva siempre tiempo, siempre 01:45:50

hagas el videojuego que hagas un poco 01:45:51

que ponga en juego varias cosas y es ir 01:45:53

poco a poco, pues ir haciendo los distintos 01:45:55

métodos, ah, necesito una 01:45:57

boleana para activar que está 01:45:59

tocando el suelo 01:46:01

vale, pues ahí empiezas a añadirla 01:46:03

en donde necesitas, entonces 01:46:05

Incluso yo también, aunque me ponga aquí a enseñaros cosas 01:46:07

Aquí veis muchos elementos 01:46:11

Pero la primera vez que hice el saltar 01:46:12

Solo ponía la condición de estoy saltando 01:46:15

Hasta que vi que, bueno, es que también necesito que esté una life 01:46:17

Porque si no, cuando se muere el personaje 01:46:20

Que hay unos segundos, ¿vale? 01:46:22

Entre que se muere el personaje y se lanza la siguiente 01:46:23

Se recarga el nivel, ¿vale? 01:46:25

Con este morir, ¿vale? 01:46:27

Pasan tres segundos, ¿vale? 01:46:28

Y luego se recarga el nivel, ¿vale? 01:46:30

En esos tres segundos, si no pongo esa condición de alive 01:46:33

Claro, el personaje muerto 01:46:36

Después de hacer la animación de muerto 01:46:38

Seguiría saltando, cosa que no tiene sentido 01:46:40

Y ahí es cuando haces el alive 01:46:43

Ah, y aparte si no detecto de alguna forma 01:46:44

Para limitar que está posado en el suelo 01:46:46

Siempre que le dé a la barra espaciadora 01:46:48

Va a saltar y va a hacer dobles, triples 01:46:50

Cuádruples saltos 01:46:53

Entonces hay que hacer algo que vaya activando y desactivando 01:46:54

Una booleana según toca suelos 01:46:56

O deja de tocar suelos 01:46:58

Y aparte si creo luego una animación de agachado 01:47:00

Y se cambia ese boss collider 01:47:02

Para que esté agachado 01:47:04

Sabéis, es complicado porque conlleva pensar 01:47:05

Es decir, te quiero decir que hay otras cosas que es a lo mejor seguir más pasos 01:47:11

Pero cuando se quiere hacer algo que no es seguir un paso a paso 01:47:16

Claro, hay que sentarse e ir viendo a ver qué necesito, a ver qué tal 01:47:19

Y es complicado, sí 01:47:23

Es el problema a estas alturas 01:47:24

Es decir, no lo digo para desanimaros, lo digo para animaros 01:47:28

No sé si lo consigo 01:47:30

Pero lo bueno de la programación es, bueno, en realidad es lo malo, que es que hay que ir dándole muchas vueltas y luego parece que algo funciona y no, pero es sobre todo ir teniendo todo como escrito, en plan, yo quiero conseguir hacer esto y para que se haga esto y traducirlo a código. 01:47:31

Pero yo estoy bastante convencido de que a código 01:47:51

Al menos esta parte sí que la sabéis hacer ya 01:47:53

No sé si os he desanimado 01:47:56

Si os he desanimado 01:47:58

Pero con lo que sabéis podéis hacer 01:47:59

Al menos lo de colocar las plataformas 01:48:02

Y que el personaje se mueva entre ellas 01:48:03

Y llegue hasta un final 01:48:06

Sí que sabéis hacerlo 01:48:07

Otra cosa es que lleva tiempo 01:48:08

Y eso no lo va a quitar nadie 01:48:10

Pues nada, muchas gracias por asistir a la tutoría 01:48:14