Tutoria 11 - DEIM - UT 6 - Curso 23·24 - 25 Abril

¿Estás con la tarea 6? ¿Qué tal la llevas? Es decir, ¿en qué punto te encuentras o cómo la estás gestionando? 00:00:01

Vale, ya he hecho lo del terreno. Estoy viendo el vídeo de Álvaro y estoy en los distintos nodos para hacer la animación. 00:00:09

Sí. 00:00:22

Vale. 00:00:23

En el animator, ¿verdad? 00:00:24

Sí. 00:00:26

En el animator. 00:00:27

En el Bren Tree. 00:00:27

Vale, estás con un 00:00:29

Entry 00:00:31

He puesto dentro de 00:00:32

Bueno, yo le he llamado 00:00:35

Corre, donde él 00:00:39

Dentro del Entry hace como tres 00:00:41

Estaciones 00:00:44

De movimientos 00:00:46

Mira Esther, si te parece 00:00:48

Como me lo vas explicando 00:00:49

Tienes ahí el proyecto abierto y lo vamos viendo 00:00:51

Sí 00:00:53

Venga, pues si quieres compárteme pantalla 00:00:54

Y lo vemos ya directamente en tu proyecto 00:00:56

Vale, ahí te tengo con el Blend Tree 00:00:59

Si te parece, dale abajo, que sale un cuadrado blanco 00:01:01

Dale a ocultar, ¿vale? 00:01:03

Para que no estéis molestando eso 00:01:04

Y lo vemos 00:01:06

Vale, tienes un Blend Tree que has llamado a correr 00:01:07

Bueno, explícamelo tú 00:01:09

Y así también voy viendo cómo lo explicas 00:01:12

Que creo que va a ser mejor 00:01:14

Vale, pues aquí en el vídeo 00:01:15

Ponía que teníamos que 00:01:19

Como en donde pone 00:01:21

O sea, aquí, ¿no? 00:01:23

El threshold, el umbral 00:01:24

Vale 00:01:27

Como darle tres parámetros 00:01:28

Como para luego 00:01:31

Hacerlo en 00:01:33

En un script, ¿no? 00:01:34

Sí 00:01:37

Entonces, él dice 00:01:37

Que 00:01:41

Él tiene de reposo 00:01:42

A correr 00:01:45

Y entonces 00:01:45

Él abre aquí esto 00:01:46

¿No? 00:01:49

Un parámetro 00:01:50

¿Float? Sí. Vale. Y yo lo que he hecho ha sido darle aquí a menos 5, porque si reposo es menos 1, entre menos 1 y 0 será menos 5. 00:01:52

Vale. 00:02:10

Porque él hace de 0 a 1, pone 0,5. 00:02:11

Vale, mira, a ver, vamos a plantear esto de otra forma 00:02:17

Tú ahora mismo, por lo que estás, corrígeme si no, por lo que estás haciendo un blend trino 00:02:21

Digamos, es para hacer los estados desde que está parado hasta que arranca a andar 00:02:26

Y incluso que vaya a correr, ¿verdad? 00:02:31

Sí 00:02:34

Vale, él lo que pasa, por lo que pone 0.5 y 1, si no me equivoco 00:02:35

Es porque tiene un joystick que tiene sensibilidad 00:02:42

Es decir, tú si das a un teclado a las teclas, puede pasar del cero, que es la nada, al uno o al menos uno, que sería el negativo. ¿Vale? Que es lo que tienes aquí. Pero realmente es un poco extraño que el idle, la animación de que está parado, que tienes ahí puesta con menos uno, ¿vale? 00:02:44

Sí. Claro, normalmente el menos uno es si estás dando un valor negativo. Si quieres el estado neutro, debería ser el cero, ¿vale? Entonces, aquí lo que se puede hacer es el id, el ponerlo en el cero, ¿vale? El caminar se podría poner en el uno y el run en el dos. ¿Por qué? Ponlo si quieres. 00:03:01

mira, el id es el 0 00:03:22

y de hecho lo vamos a hacer todo 00:03:23

porque los dos parámetros de inicio, andar 00:03:25

inicio, correr, ¿por qué los has puesto? 00:03:28

¿de cara a este 00:03:31

blendtree o para otras cosas? 00:03:32

porque si 00:03:34

no, de cara a esto 00:03:35

vale, si lo digo porque si no 00:03:38

no es necesario, vale, mira 00:03:40

de hecho te voy a pedir que borres 00:03:41

los dos parámetros que no está 00:03:44

si no los estás usando para otra cosa 00:03:45

el que pone inicio, andar, inicio, correr 00:03:47

clic derecho y borralos 00:03:49

¿vale? para que veas que no hace falta 00:03:52

se puede usar para más cosas pero 00:03:54

de momento vamos a ir a lo básico 00:03:55

vale, lo primero 00:03:57

el personaje, para ir viendo 00:03:59

luego cómo funciona, el personaje 00:04:02

que tiene esto, que entiendo 00:04:04

no sé si es Izan o el que pone Armature 00:04:06

¿cuál sería? 00:04:08

no, es que ¿sabes qué pasa? 00:04:10

que es que he descargado 00:04:12

los dos, uno que era 00:04:14

el primero 00:04:15

y luego en el resto 00:04:17

de los apuntes, o sea 00:04:20

en el vídeo era el que 00:04:22

hacía él 00:04:24

O sea, Izan 00:04:25

era el del vídeo 00:04:28

Vale, enséñamelos y vemos 00:04:29

qué tiene cada uno, porque como hay que aplicarlo 00:04:32

a una de las geometrías, a uno de los 00:04:34

personajes... Es que el de Izan 00:04:36

no me salía bien, porque 00:04:38

a ver, yo 00:04:40

cuando yo lo descargué y todo 00:04:41

en el 00:04:44

O sea, en el animator, cuando hay que ir a Rig, que este tiene como dos fallos y tal, pues lo puse, pero es que resulta que me anda de lado, ¿sabes? 00:04:46

Vale, lo podemos ver y así vemos qué ocurre. 00:04:58

Es que creo que lo he borrado, creo. 00:05:02

Vale. 00:05:04

Sí, simplemente es ahora mismo en la escena con qué personaje vas a ir trabajando, por explicarlo algo. 00:05:06

Ah, con este, con el... 00:05:11

Vale, el Izan incluso, si no lo usas, bórralo. 00:05:12

Y enséame el panel de escena. 00:05:14

Es que si no, no sé bien qué estamos haciendo, ¿vale? 00:05:16

Vale. 00:05:20

Ahora mismo tenemos en el que estás configurando el Blend Tree, ¿para qué objeto va a ser? 00:05:20

¿Para qué personaje? 00:05:26

Para este. 00:05:27

Para ese, vale. 00:05:28

Pues el de Ethan, si quieres no lo borres, pero ocúltalo. 00:05:29

Es decir, dale en el inspector, dale al tick, a la derecha del inspector, pues donde... 00:05:32

Seleccionalo y dale al tick que está a la izquierda donde pone Ethan. 00:05:38

Ah, vale. 00:05:42

¿Vale? Para que no esté molestando. 00:05:43

Vale, vale. 00:05:44

Vale, entonces ahora Armature, selecciónalo para ver su inspector, para ver qué tiene aplicado. Lo digo porque es que si no igual hacemos cosas y luego no se ve. Vale, Armature tiene un Animator Controller que se llama Armature, perfecto. Y tiene el avatar y entiendo que tiene todo bien seleccionado porque las animaciones de Idle y Avanzar y eso, ¿de dónde las has sacado? ¿Del Mixamo? 00:05:45

Sí, de aquí 00:06:08

A ver, de aquí 00:06:10

O sea, de todo esto 00:06:12

¿Y armature de dónde sale? 00:06:15

Lo que es el muñeco 00:06:17

¿Esto? 00:06:18

No, el personaje 00:06:20

¿Ese os lo compartí yo? 00:06:23

No 00:06:26

Esto viene en los apuntes 00:06:26

Ah, vale, es el otro personaje 00:06:28

Que te ha bajado de los apuntes, vale, vale 00:06:31

Ya entiendo, vale, que estamos juntando 00:06:32

Los dos, vale, perfecto 00:06:35

Pero este vale, ¿no? 00:06:36

es que lo que ponía aquí 00:06:37

que había que 00:06:40

se puede hacer 00:06:42

en Mixamo 00:06:43

y como no 00:06:45

sea así mucho pues 00:06:48

he cogido este 00:06:50

es decir, de cara a la práctica a mí lo que me interesa 00:06:51

es que a un personaje lo podáis mover 00:06:54

me da igual cual sea 00:06:56

lo que sí, que para sacar diferentes 00:06:57

animaciones, aunque aquí estás cogiendo 00:07:00

las que 00:07:02

pasaba ya en el paquete 00:07:04

que están ahí marcadas 00:07:06

ahí ya están hechas, lo bueno de Mixamo es que tú puedes 00:07:07

meter cualquier personaje y puedes 00:07:09

sacar más animaciones, pero bueno 00:07:12

vamos a hacerlo con estas que tenemos aquí 00:07:13

entonces 00:07:15

ahora mismo tú tienes 00:07:16

ese 00:07:20

personaje con ese animator 00:07:20

vamos adentro con el animator, otra vez 00:07:23

ya sé entonces 00:07:26

cómo está contextualizado 00:07:27

ahora mismo tienes un estado de idle 00:07:29

por lo que veo 00:07:31

que esa animación es que está 00:07:32

quieto, y luego 00:07:35

lo que vas a 00:07:37

querer es 00:07:39

que corra, entonces 00:07:40

o sea 00:07:43

o sea 00:07:45

de tranquilo 00:07:47

andar y correr 00:07:49

yo lo que he puesto aquí, no sé 00:07:50

o sea, andar, correr 00:07:53

vale, esto 00:07:55

por ejemplo funciona más 00:07:57

y vamos a 00:07:58

hacerlo así ahora mismo si te parece 00:08:00

Funciona más para, digamos, opuestos 00:08:02

Igual que el getAxis sirve para tener el menos uno y el uno 00:08:07

¿Sabes de qué te voy hablando? 00:08:11

De que es un input que permite coger dos extremos 00:08:13

Este lo vamos a hacer para ir, por ejemplo, hacia adelante y hacia atrás 00:08:15

Más que hacia adelante y hacia correr 00:08:20

Ahora te digo el porqué 00:08:22

Vale, es que en el vídeo pone de parado a correr 00:08:23

De 0 a 0,5 y a 1 00:08:30

Claro, pero ahí tienes que tener en cuenta 00:08:31

Que es que el GetAxis que está usando 00:08:33

Tiene valores intermedios 00:08:35

Entonces tú si coges 00:08:37

A no ser que me digas que tú estás haciéndolo con un Gamepad 00:08:39

Con un mando de consola 00:08:41

Tú si el joystick 00:08:43

Que estás configurando para coger el GetAxis 00:08:45

No lo tocas 00:08:47

Está en 0 y por tanto está en el idle 00:08:49

Si lo mueves un poquito 00:08:51

Hacia arriba 00:08:53

Irá sumando decimales hasta el 1 que es el máximo 00:08:54

Entonces tú empujando un poquito 00:08:57

tú haces que el personaje ande, ¿vale? 00:08:59

Y al subirlo del todo, corre. 00:09:02

Pero tú en un teclado, si es con lo que estás trabajando, 00:09:04

eso no lo puedes hacer. 00:09:06

Ah, vale, vale. 00:09:07

Porque tú la tecla, sí. 00:09:08

Claro, es que yo pensaba, o sea, él dice una frase, 00:09:10

¿por qué pongo menos uno? 00:09:13

Porque él en correr pone correr para adelante, 00:09:14

correr hacia la izquierda y correr a la derecha, ¿vale? 00:09:19

Entonces, yo veía como tres estados, pero, ¿sabes? 00:09:22

Pero distintos. 00:09:26

entonces, él dice, ¿por qué pongo 00:09:26

él pone menos uno para 00:09:29

normal, cero 00:09:31

para la izquierda y 00:09:33

menos uno para la derecha, ¿no? 00:09:34

entonces, él dice, ¿por qué pongo 00:09:37

estos para luego hacer el 00:09:39

script? entonces, claro, yo he 00:09:41

relacionado ese script 00:09:43

con 00:09:45

luego las teclas, ¿sabes? no con un 00:09:45

joystick. Claro, si 00:09:49

depende de cómo se haga, hay que saber cómo 00:09:51

se juega, digamos, es decir 00:09:53

hay que pensar, pues eso, que una tecla 00:09:55

tú cuando pulsas en el teclado no hay valores 00:09:58

intermedios, o la pulsas que es uno 00:10:00

o la sueltas y es cero 00:10:01

entonces, hay cosas 00:10:03

que se pueden hacer con un joystick porque tiene una 00:10:06

sensibilidad intermedia y otros 00:10:07

inputs, otros 00:10:10

dispositivos que no, es decir 00:10:11

tú si tienes un mando, por ejemplo, de Xbox 00:10:14

que se puede conectar al ordenador 00:10:15

esto se podría hacer y Álvaro lo está haciendo en base a eso 00:10:17

¿vale? pero 00:10:20

hay que ir pensando según 00:10:21

que se vaya haciendo 00:10:23

entonces, para lo que sí 00:10:25

se puede hacer, por ejemplo 00:10:27

lo que podemos probar 00:10:28

es que el id sea 0, es decir 00:10:31

no estás tocando nada y está parado el personaje 00:10:33

si le damos por ejemplo la w 00:10:35

por decir una flecha 00:10:37

una dirección de hacia adelante, sería el 00:10:38

caminado normal y sería un 1 00:10:41

en realidad, y luego 00:10:43

el correr lo vamos a poner con 00:10:45

un 2, pero no porque 00:10:47

hay una tecla que sea 00:10:49

2, el valor lo va a recoger 00:10:51

como 1 o tecla pulsada 00:10:53

pero sí que podemos decir de alguna forma 00:10:55

que si estás dando adelante y aparte 00:10:57

pues por ejemplo pulsas el shift 00:10:59

valga 2 y entonces 00:11:01

el blend tree irá al 2 00:11:03

¿vale? vale, vale 00:11:05

si quieres 00:11:07

lo hago yo o prefieres que 00:11:08

lo hagamos contigo, lo digo 00:11:11

es decir 00:11:12

que no sé que es más ágil 00:11:13

yo creo que es más ágil si lo voy haciendo contigo 00:11:16

ah, vale 00:11:19

o prefieres que vea como lo hago yo 00:11:20

Sí, es que ¿sabes qué pasa? Que estoy más pendiente de lo que me estás diciendo que realmente verlo y así me quedo yo con el... 00:11:22

Venga, pues vamos a ello. Lo del mixamo, por ejemplo, no lo has intentado, ¿no? Lo digo a hacer algo con mixamo del personaje. Estás usando el armature, ¿no? Básicamente de... 00:11:33

si he visto si he visto que hay los apuntes como lo descargarlo y también 00:11:44

he visto una cosa que no he entendido muy bien que es que pone por ejemplo 00:11:53

aquí no por ejemplo si tú el muñeco quieres que meta la mano en para como 00:12:02

para desenfundar, como que había que tener cuidado de no meterlo entre las mallas o... 00:12:11

Vale, vale, venga, pues vamos a hacer una cosa, dale otra vez al botón de dejar de 00:12:20

compartir y comparto yo, vale, entonces, a ver, me encantaría hacerlo, vale, de hecho, 00:12:27

si me das un segundo, yo tengo otros personajes, pero incluso para que sea con el mismo me 00:12:35

lo bajo de los apuntes el que estás usando tú vale y lo hacemos juntos y así al menos lo que 00:12:40

es el enfoque primero lo vemos juntos dame un segundo porque esto estaba en dame en el tema 00:12:45

6 y si cuando se explicaba lo que era el ejemplo del carácter controller si no me equivoco pero 00:12:51

bajo vale dame un segundo que tardo poco vale vale el que entiendo que estás usando es un 00:12:59

paquetes que se llama izan estándar a sets verdad no me bajé el izan y luego 00:13:09

como no sabía cómo me lío un poco porque había que cambiar tenía mal como la 00:13:18

cadera y el esternón y tal pues luego me bajé el otro el de llama armature si 00:13:24

los starter assets vale sí lo hacemos con el izan que en el fondo 00:13:32

es lo mismo? Ah, vale, sí. Vale, lo digo porque el otro hay que bajarlo del asset store, ¿vale? Y tarda un poquito más. Ah, bueno, no pasa nada. Vale, entonces, dame un segundiete, que lo que sí voy a hacer es otro proyecto distinto. Bueno, en realidad voy a hacer otra escena y ya está. Un segundo. Vale, la cosa es eso, que en los vídeos habla de valores intermedios, pero aquí nada, es un poco lo que también nos está 00:13:39

liando 00:14:11

entonces 00:14:13

ahora mismo 00:14:14

voy a crear una nueva escena 00:14:17

que se va a llamar 00:14:20

tutorial, por ejemplo 00:14:21

y aquí voy a importar 00:14:23

el paquete 00:14:26

de Izan 00:14:27

un segundo 00:14:28

importo 00:14:29

y me lo ha metido aquí un poco 00:14:36

me ha juntado un poco todo, pero bueno 00:14:44

por aquí tiene que estar 00:14:48

Character, third person 00:14:50

Models, Ethan 00:14:53

Vale, voy a poner un plano 00:14:54

Que lo suyo es hacer 00:14:56

Un 00:14:59

Un paisaje 00:14:59

De hecho, mira, voy a hacer un 00:15:01

Un terreno, terrain test 00:15:04

Esto más o menos si lo sigo haciendo 00:15:06

Voy a hacer uno de 500 por 500, así rápidamente 00:15:08

Que no tenga más, vale 00:15:10

Y pongo a Ethan aquí 00:15:12

Vamos a poner aquí a Ethan 00:15:14

Bueno, se nos ha quedado ahí pequeñete 00:15:17

pero da igual, ¿vale? Va a estar todo con sus colorines. 00:15:19

Vale, entonces, este personaje, que pasará lo mismo que Izan, 00:15:23

luego es un FBX que dentro tiene, aparte de la malla y las texturas, etc., 00:15:26

lo que se llama el armature, que es el rig, es decir, la distribución de huesos, etc., 00:15:32

que viene aquí ya como configurado, con todos los huesos. 00:15:39

Esa es la diferencia o la clave de que Mixamo ayuda mucho. 00:15:43

En el caso de que tengáis un personaje que hayáis modelado, pues por ejemplo tenéis este personaje pero no lo tenéis rigado, pues a lo mejor lo podéis meter en Mixamo y ya os da toda la estructura de esqueleto, que es algo bastante complejo de hacer directamente en un software de 3D. 00:15:46

Una vez tenemos ya el avatar, que el avatar es esa estructura de huesos ya bien vinculados con las distintas articulaciones y tal, lo que hacemos es ese controller, por ejemplo, lo voy a hacer aquí un poco de aquella manera, ese controller, es decir, me refiero que lo voy a hacer aquí todo junto, que por ejemplo en este caso va a ser Izan. 00:16:02

Voy rápido porque entiendo que esto es un poco lo que ya ha sido trabajando, ¿vale? Cuando tenemos un personaje y queremos que tenga esos parámetros, bueno, esto es con otro animator distinto, ¿vale? Pero ese animator se corresponde con uno que está en otro lado, pero en este caso vamos a querer usar uno que he hecho doble clic, que es el de Ethan, que está esperando a que hagamos algo con él, ¿vale? 00:16:24

Lo que queremos para que funcione es que todo lo que trabajemos aquí dentro, pues tendrá que el componente animator, pues que estar vinculado a este objeto, ¿vale? 00:16:49

Entonces, ahora mismo tenemos este personaje y yo tengo por aquí diferentes animaciones, ¿vale? 00:17:00

Que lo mismo, en Mixamo se pueden ir bajando muchas, pero que tenemos aquí pues preparadas para ir usando, ¿vale? 00:17:08

Son distintas animaciones, pues, por ejemplo, a ver qué nombre tenemos, con control y ruleta, ¿vale? 00:17:14

Hago esto de que se pueda leer los nombres para no volvernos locos. 00:17:21

Entonces, dime. 00:17:25

Una pregunta, o sea, tú en Misamo vas, te descargas lo que son las animaciones solo, te las importas al proyecto este, ¿no? 00:17:26

Eso es. 00:17:35

Y de aquí te lo tienes que meter en la carpeta de personaje, ¿no? 00:17:36

Lo pueden meter en cualquier punto de los assets. 00:17:43

En cualquier carpeta dentro de... 00:17:45

De los assets, exacto, en donde sea. 00:17:47

De hecho, ahora mismo se me ha importado aquí en animación, 00:17:50

porque como he importado un paquete, 00:17:53

se me ha hecho como otra estructura aquí 00:17:55

y luego, si te fijas, 00:17:56

yo tenía otras animaciones antes de otros personajes, ¿vale? 00:17:58

Es decir, que el punto donde esté no importa tanto, ¿sí? 00:18:01

Lo que sí que importa es que lo que va a bajar, 00:18:05

aunque le demos al exportar de Mixamo, 00:18:08

le digamos que no queremos la skin, 00:18:11

Es decir, no queremos que tenga geometría, sino solo lo que es el clip de animación, aún así te lo emparqueta en un FBX, ¿vale? Y aunque no tenga animación, digamos, una geometría, una malla, ¿vale? No sale aquí el personaje en sí, lo que sí nos da es una especie de rig ya hecho que coincide con la animación que tenemos aquí, ¿vale? 00:18:13

Que es este iconito que tenemos aquí de animaciones, ¿vale? 00:18:35

Este es el icono de avatar y este el de animaciones. 00:18:38

De hecho, si damos doble clic a uno, a mí se me ha abierto la otra pantalla, 00:18:40

pero te abrirá lo que es la animación relacionada con todos los diferentes elementos que ha generado para el rig, ¿no? 00:18:44

¿Y esto se corresponde con la estructura interna de tu personaje, de tu avatar? 00:18:52

Ahí está la clave. 00:18:58

Que si tú el avatar lo haces con Mixamo, luego hagas el personaje que hagas y saques la animación que hagas, al final, cómo nombra a los huesos y cómo los distribuye son siempre los mismos. 00:18:59

Entonces, cualquier animación que sacas de Mixamo es compatible, ¿vale? Porque digamos que respeta la misma estructura. 00:19:13

Si ya lo empiezas a coger de otros puntos 00:19:19

Tienes que ir haciendo coincidir 00:19:22

Pues que la articulación 00:19:24

De ese objeto 00:19:26

Pues se corresponda con este avatar 00:19:27

Pero la gracia es que si tú haces un personaje 00:19:29

Y ya lo rigueas 00:19:32

Por ejemplo en Mixamo 00:19:33

El avatar de todas las animaciones que vas sacando de Mixamo 00:19:35

Es la misma 00:19:38

Entonces digamos que todas se dirigen 00:19:39

A una misma estructura de huesos 00:19:41

¿Esto por qué lo digo? 00:19:43

Porque también 00:19:46

cuando tenemos estos distintos 00:19:47

FBX 00:19:49

que en realidad son solo animaciones 00:19:51

aunque sean FBX 00:19:53

por eso hay que hacer este paso intermedio 00:19:54

que decía de, bueno aparte de ajustar 00:19:57

tamaño y tal, que en principio si todos son 00:19:59

los mismos no habría que hacer nada 00:20:01

pero en rig sí que hay que decirle 00:20:03

¿vale? porque esto es una de las cosas 00:20:05

que se dice en los apuntes 00:20:07

que es que tiene que ser un hombre 00:20:08

vamos, un hombre, una mujer, un vípero 00:20:10

una persona, vaya, entonces 00:20:12

es una de las limitaciones que tiene 00:20:14

Pero lo bueno es que tú puedes decirle que esta animación, que en este caso, pues he cogido una cualquiera, pero es la de salto y caída, por lo que veo, ¿vale? Tú puedes decirle, vale, yo no quiero que coja su propio avatar, quiero que respete el avatar original que yo estoy usando, bueno, me pide que le diga ok, pero el avatar original que habría que buscar, que yo estoy usando, y además es este, en el animator. 00:20:17

Bueno, me dice que aplicar, ¿vale? Este cambio, pero yo en el animator ya tengo un avatar, ¿vale? Que es el que está configurado para ese personaje. Si yo estoy usando un avatar, una estructura de rig hecha en Mixamo, todas las animaciones están pensadas para ese, para ese, para esa animación, ¿vale? 00:20:41

Entonces, por ejemplo, aquí voy a buscar el de, un segundito, el control aquí, primero la de Idle, que es como digamos la que más nos interesa y de hecho, voy a decir que lo coja de, de Izan Avatar, vale, vamos a, ¿dónde está? Que se me ha ido, esta. 00:21:01

Que además, si te metes en la animación 00:21:25

Aquí te sale con otro elemento 00:21:27

Porque no le hemos todavía asignado ningún modelo 00:21:30

Pues se ve aquí la miniatura de qué hace esa animación 00:21:32

¿Vale? 00:21:35

Vale, entonces 00:21:36

Si te fijas, para asignar qué hace esta animación 00:21:38

Hay que ir al FBX padre 00:21:41

Y decirle, yo quiero que esto lo coja de otro avatar 00:21:42

Que es el de Ethan 00:21:45

Y espero que no esté ese 00:21:46

El de Ethan, ¿vale? 00:21:47

Y lo aplico 00:21:49

¿Esto qué significa? 00:21:50

Que si yo ahora, vamos a hacer la prueba 00:21:52

Todavía no tengo nada en el 00:21:54

Si yo no tengo nada en el animator 00:21:57

¿Vale? 00:21:59

Y me voy a verlo en escena 00:21:59

Cuando le de a play 00:22:02

Pues está quieto 00:22:03

Si te fijas, no está haciendo nada 00:22:06

Está como encogido, es decir, los huesos se han encogido 00:22:07

Aquí no hay ninguna animación 00:22:10

Que se esté desencadenando 00:22:11

¿Qué puedo hacer yo ahora? 00:22:14

Decir, vale, yo ya he configurado la de 00:22:16

A ver, ¿dónde lo he puesto? 00:22:18

La de idle 00:22:19

Y yo puedo 00:22:20

¿Dónde me la ha dejado ahora? 00:22:25

Espera, porque no me lo ha cogido 00:22:33

Un segundín, ¿eh? 00:22:35

Claro, el problema es que estoy juntando 00:22:44

los avatares de Ethan con el de 00:22:46

Standards Assets 00:22:48

Entonces, lo que vamos a hacer 00:22:49

es pensar otra cosa, que es que 00:22:51

este avatar del que estoy usando 00:22:54

estas animaciones 00:22:56

porque este, por el que me está haciendo 00:22:57

aquí el mismatch, lo que vamos a decir es 00:23:00

que sea esta de Idle 00:23:02

Este de idle 00:23:03

El que defina el avatar de este modelo 00:23:04

¿Vale? 00:23:07

Entonces al darle aquí nos ha creado este avatar 00:23:08

Y le voy a decir que el que se use 00:23:11

En las animaciones 00:23:13

Sea este que tengo aquí 00:23:15

A ver ahora cuando le de 00:23:16

Lo que pasa es que como estoy juntando 00:23:18

De dos sitios 00:23:20

Porque estoy usando el izan y otras animaciones que tenía 00:23:22

Se me está volviendo un poco loco 00:23:25

Pero mira, ahora está quieto sin hacer nada 00:23:27

¿Vale? 00:23:29

Si yo ahora le digo en el animator 00:23:29

que coja esta animación 00:23:32

y se desencadene por defecto 00:23:34

ya por defecto vamos a tener 00:23:36

que el personaje está 00:23:38

y si vamos aquí 00:23:39

a ver 00:23:41

si le damos al play 00:23:42

este personaje 00:23:49

debería estar haciendo el 00:23:51

idle, que es el que tenemos aquí 00:23:53

¿por qué no lo está haciendo? 00:23:55

vemos aquí 00:23:58

¿dónde está cogiendo el? 00:23:59

Un segundo 00:24:02

Pues vaya tela 00:24:09

Te estoy aquí soltando una chapa 00:24:15

Y no me hace ni caso 00:24:17

A ver, un segundo 00:24:18

Está habiendo un problema con el avatar que está viendo 00:24:19

A ver, modelos 00:24:29

Izan, quiero el avatar de Izan 00:24:33

Voy a volver a esto, que es el que está dando el problema 00:24:35

Lo cojo de ahí 00:24:37

Y las animaciones de Izan 00:24:39

Pues yo lo que quiero es 00:24:41

Que esta coja, lo voy a volver a hacer, ¿vale? 00:24:42

Perdona, lo voy a volver a coger del Izan 00:24:45

Lo aplico 00:24:48

¿Y por qué me da fallo? 00:24:49

Si es que está cogiendo el mismo 00:24:51

Esto es porque es de dos elementos 00:24:53

Que tienen una estructura de huesos distinta 00:24:56

Entonces no me lo está cogiendo bien 00:24:59

Pero debería estar cogiéndolo bien 00:25:01

Porque es del mismo paquete 00:25:02

Entonces 00:25:04

Voy a hacer otra cosa 00:25:06

si no, hacemos la solución del mixamo 00:25:11

y ya verás como con eso se soluciona 00:25:15

pero 00:25:17

vamos a hacer una cosa 00:25:18

voy a hacer un proyecto nuevo 00:25:38

porque se me está mezclando lo de todos los proyectos 00:25:39

y creo que eso es uno de los problemas 00:25:42

a ver, voy a 00:25:44

voy a hacer un nuevo proyecto 00:25:46

estoy abriendo el Unity Hub 00:25:49

hago un nuevo proyecto 00:25:51

en la versión que estamos usando siempre 00:25:52

el 3D 00:25:54

Proyecto Tutoría 00:25:55

Vale, y lo voy a guardar en 00:25:58

En el escritorio mismo 00:26:00

Aquí, Proyecto Tutoría 00:26:03

Tutoría 00:26:05

Ahí está 00:26:08

Ahí está, y lo creo 00:26:09

Vale 00:26:12

Y vamos a empezar rápidamente a hacerlo 00:26:13

Porque algo ha fallado 00:26:17

Y creo que es 00:26:18

Están mezclando distintos avatares 00:26:19

Sí, ¿no? 00:26:22

A ver 00:26:25

vuelvo a importar el paquete 00:26:26

inserto todo 00:26:29

vale, debería estar todo bien 00:26:32

importo 00:26:35

vale, entonces 00:26:36

si nos metemos en esta escena 00:26:39

vale, tenemos aquí al personaje 00:26:41

que el que vamos a usar es 00:26:44

el modelo de Ethan 00:26:48

y Ethan tiene su propio avatar, etc 00:26:49

lo vuelvo a meter 00:26:52

hago un terreno 00:26:54

como he hecho antes lo hago todo rápido bueno habría que habría que importar las terrain tools 00:26:56

entonces voy a hacer un plano ahí está con izan ahí puesto vale y lo tenemos aquí el 00:27:04

animator controller lo voy a crear de cero animator controller el personaje ahora que 00:27:13

no hay más, ponemos ese, y aquí tenemos al personaje. Vale, el avatar de Ethan tiene 00:27:21

esto seleccionado ya para poder entrar. Entonces, si vamos a las animaciones, y por ejemplo 00:27:28

vemos el Idle, vamos a volver a ir al Idle, lo que queremos es que este modelo, esta animación, 00:27:36

etcétera, ¿vale? Esta animación se configure en Idle, lo coja de otro avatar, que es el 00:27:43

de izan y lo aplicamos y me vuelve a decir lo mismo y esto es por qué entonces no está 00:27:50

cogiendo bien este avatar y por qué si además es que este modelo lo chequeé antes de subirlo 00:28:01

iba todo bien a ver pero evidentemente algo no está yendo todo bien porque a ver si usamos 00:28:16

Y está cogiendo el avatar de Ethan 00:28:29

Y aquí sí lo está haciendo 00:28:40

Vale, un segundete 00:28:42

Un segundo, perdona 00:28:46

Sí, sí 00:28:52

Claro, pero sí que lo está cogiendo 00:28:53

De este modelo 00:28:58

Vale, bueno, tiene pinta que 00:28:59

Este no se hizo en Mixamo 00:29:02

Y como que en vez de vincularlo 00:29:03

con el avatar de otro objeto 00:29:05

hay que confiar en que 00:29:07

cada una de las animaciones 00:29:09

está hecha con el mismo 00:29:11

rig y si no, no lo está 00:29:14

cogiendo bien. A ver, voy a hacer... 00:29:16

Este es de Unity, no sé si... 00:29:17

Este objeto... 00:29:20

El humanoide... 00:29:21

Este objeto viene de 00:29:23

un paquete que os he dado yo. 00:29:25

Sí, pero el otro 00:29:27

que estaba usando yo es de... 00:29:29

Sí, el otro sí. 00:29:32

Sí, sí, el problema a veces es saber, cuando te vienen de terceros, por eso lo de Mixamo ayuda, cuando vienen de terceros es saber si la estructura de huesos de todas las animaciones coincide. 00:29:33

Es decir, si... a ver, estoy perdiendo mucho tiempo en esto y estamos sin ver lo que importa, pero simplemente para que veamos lo que pasa, ¿vale? 00:29:45

Porque esta estructura habrá sido hecha en varios objetos distintos, ¿vale? Y no todos respetan este avatar, no todos, digamos, que se asocien con este avatar. 00:29:58

Entonces, cuando yo, por ejemplo, quiero, aunque lo normal sería decir que coja la estructura del objeto padre, aquí realmente lo que habrá que decirle es que respete la de su propio objeto. 00:30:08

Y aunque no se esté referenciando directamente con el avatar, y voy a ponerle la animación, a ver, ¿dónde he hecho yo la animación? 00:30:20

He hecho yo un personaje, un controller, que cuando se junta aquí, ahora sí que cuando me meto en ese controller y meto esa animación que le estoy diciendo, coge tu propia animación de tu propio rig, ahora sí que cuando lo arrastro aquí debería responder. 00:30:32

y ahí está, vale 00:30:56

entonces es algo 00:30:59

que a veces pasa que es 00:31:00

si estamos vinculando, digamos 00:31:02

todas las animaciones a un mismo rig, como cuando 00:31:05

lo que explico en el vídeo que hay en el tema 00:31:07

cuando estamos sacando 00:31:09

las animaciones a partir de Mixamo 00:31:11

o si nos pasan distintos 00:31:12

digamos FBX con animaciones 00:31:14

pero digamos que se han sacado de manera 00:31:16

independiente, pues no 00:31:18

puede haber problemas de que no se vincule 00:31:21

y es lo que está pasando aquí, en tu caso 00:31:22

yo imagino que si eso, que si buscas 00:31:25

el avatar 00:31:27

el mismo avatar que se 00:31:27

está vinculando como padre 00:31:30

en el animator, debería funcionar bien 00:31:32

¿vale? 00:31:35

si no, a ver 00:31:36

si me da 5 minutos, me bajo el armature 00:31:37

y lo hacemos exactamente igual 00:31:41

que igual es mejor 00:31:42

porque si no, me voy a 00:31:43

hablar de casos que igual hay que reconfigurar 00:31:46

cosas, que es que es verdad que esto es 00:31:49

peliagudo, hay que ir probando 00:31:51

también a veces, hasta que vemos que 00:31:52

va respondiendo las cosas. Pero 00:31:54

si quieres, me bajo ese 00:31:56

paquete y lo vemos juntos, ¿te parece? 00:31:58

Lo que quieras. 00:32:02

O sea, yo lo que tenía dudas 00:32:03

es en el de 00:32:04

menos uno, cero, uno, pero... 00:32:05

Vale. Sí, bueno, 00:32:08

si no te lo explico aquí con este, sí, porque 00:32:10

en el otro ya conseguí. Vale, vale, vale. 00:32:12

Que como quieras, sabes que... 00:32:14

Vamos a hacerlo con este. Me da igual. 00:32:16

Entonces, lo que vamos a hacer aquí, ¿vale? 00:32:18

Para ir haciéndolo rápido, es un blend tree 00:32:20

que se va a llamar, cuando me meto, 00:32:22

pues que se va a llamar correr, ¿no? Tú lo habías llamado caminado, yo que sé, lo que sea, da igual, esto en realidad no importa mucho. 00:32:24

Lo que sí importa es este parámetro, que es con el que vamos a vincular el input que vayamos haciendo, ¿vale? 00:32:33

Y entonces vamos a tener un estado que será el de idle, lo pasa que como ya lo he usado, lo voy a borrar de aquí, 00:32:40

Y me meto aquí y en el de idle, a ver, porque primero habrá que decirle que al blend tree hay que meterle las animaciones, ¿vale? Y en este caso tú lo que habías hecho y lo que hacía Álvaro, ¿no? Que esta es una referencia es que está la de parado, la de caminar para adelante, que por ejemplo sería aquí y habrá que hacer esta nueva configuración de crear por este modelo, ¿vale? 00:32:51

Ya está configurada, que es andar hacia adelante, ¿vale? 00:33:16

Aquí hay una cosa importante, que es que si te fijas, que también lo digo en el vídeo, 00:33:21

si te fijas al reproducir el clip este de animación, 00:33:27

vemos que el personaje no es solo que haga como el ciclo de caminado, 00:33:33

sino que aparte se está desplazando, porque ves que la malla del suelo se está moviendo, ¿vale? 00:33:37

aquí hay un detalle a tener en cuenta 00:33:42

que es que cuando la animación ya tiene 00:33:44

su propio movimiento 00:33:46

el personaje se va a mover 00:33:48

en este caso hacia adelante 00:33:50

igual que hace aquí 00:33:51

la escena no se me mueve 00:33:53

anda pero no se desplaza 00:33:56

no se desplaza 00:33:58

eso en principio es porque 00:33:59

entonces tiene desactivado 00:34:02

y chequéalo en el animator 00:34:04

esto de aplicar root motion, esto está desmarcado 00:34:06

A ver 00:34:08

Míralo un segundo, también sabe 00:34:11

¿Cuál has dicho? 00:34:13

¿El de debajo de la batalla? 00:34:17

Está con el 00:34:19

Chequeado 00:34:22

¿Está chequeado? 00:34:22

Vale, ¿y tú has conseguido que el personaje anda y no avanza? 00:34:24

Dices 00:34:27

Sí 00:34:28

Bueno, estamos hablando de una cosa un poco 00:34:32

Absurda, perdóname 00:34:36

Porque claro, yo estoy hablando de mi modelo, no del tuyo 00:34:37

Que el tuyo en el caminado igual está en su sitio 00:34:40

pero que en el vídeo se habla de que 00:34:42

las propias animaciones pueden tener sus propios 00:34:44

movimientos, si eso es así, habría que 00:34:46

desactivar, lo digo porque nos puede distraer, habría que 00:34:48

desactivar esto, de hecho yo lo voy a tener que desactivar 00:34:50

en un segundo, pero 00:34:52

lo digo porque hay que pensar, igual que 00:34:54

pasaba en 2D, que lo que vamos a hacer 00:34:56

por un lado es los movimientos 00:34:58

como las animaciones que tienen los 00:35:00

personajes, pero lo que es el desplazamiento 00:35:02

en el espacio lo vamos a hacer por código 00:35:04

con un translate, con un... 00:35:06

Eso es lo que ponen los apuntes, que eso hay que 00:35:07

quitarlo si tú lo quieres que se mueva 00:35:10

por código. Eso es. 00:35:12

Porque a veces podemos tener animaciones 00:35:14

que es que la animación 00:35:16

está moviéndose o que 00:35:17

solo haga como que anda, pero el suelo está quieto. 00:35:20

¿Sabes lo que quiero decir? Vale. Sí. 00:35:22

Eso es importante porque si no 00:35:24

lo desmarcáramos en algún momento, decimos 00:35:26

anda, ¿y por qué se está yendo para adelante? Y de hecho lo vamos 00:35:28

a ver, ¿vale? Ahora vamos a ver cuándo lo hagamos. 00:35:30

Vamos a decir, ¿y esto por qué se mueve? 00:35:32

Si yo no le he dicho que se mueva. Y es porque la propia animación 00:35:34

ya tiene movimiento. Igual que se mueven los brazos, 00:35:36

pues está marcado que se mueva hacia adelante 00:35:38

pero esto se 00:35:41

consigue quitando la playroom motion 00:35:42

y luego lo que se 00:35:45

pone en el vídeo también, hay otro tipo 00:35:46

de animaciones 00:35:49

de la Y 00:35:50

que en el ejemplo del vídeo por ejemplo 00:35:53

se habla de la Y porque hay animaciones 00:35:55

de salto que el personaje de verdad 00:35:57

sube y lo que queremos nuevamente es 00:35:59

que el impulso lo coja 00:36:01

por código 00:36:03

que le demos la fuerza 00:36:05

Entonces esto es donde hay que ir chequeando estas configuraciones. Pero vamos con el blend tree. Vamos a ir poniendo las distintas animaciones. Tenemos la de estar en reposo, la de caminar. 00:36:06

que a ver si me deja, que hay que ajuntarla, siempre la arrastro, pero hay que ponerla aquí, ¿vale? Y luego una que habrá aquí de correr, por ejemplo esta, que si yo la chequeo, pues corre y nuevamente también se mueve el suelo. 00:36:29

Pero bueno, ahora vemos cómo solucionar eso. Entonces yo la pongo aquí, ¿vale? Y le voy a decir que no me los haga automático, sino que yo voy a poner el valor. 00:36:43

Álvaro lo que tenía era algo como esto 00:36:53

0, 0,5 y 1 00:36:56

¿Vale? Pero el problema, que yo para que camine 00:36:57

Le voy a tener que poner un 1 00:37:00

Que es 00:37:02

Que se está cogiendo 00:37:02

En un axis el máximo del axis 00:37:06

Si lo cogemos con un axis 00:37:08

Esto se puede coger de distintas formas 00:37:09

Y lo que vamos a decirle es que el ran sea el 2 00:37:12

¿Vale? Para que cuando vayamos 00:37:14

Pasando de uno a otro y le damos a play 00:37:16

Pues si yo pulso 00:37:18

La tecla 00:37:20

Si yo pulso la tecla y esto va al 1, va caminando, pero si conseguimos que el valor que llegue a este parámetro blend, que es el que tenemos aquí, pero se llama blend porque es el que no se ha creado por defecto, pero vamos a poner caminado. 00:37:21

Estamos diciendo que lo que entre en este parámetro sea lo que determine qué animación se desencadena. 00:37:36

Y si está en el 2, pues irá en el 2. 00:37:42

Entonces vamos al código ahora mismo. 00:37:46

Hay que hacer un código básicamente para que detecte los inputs y detecte todo lo que vamos haciendo. Esto habría que meterlo en una carpeta un poquito más, pero lo voy haciendo un poco rápido para que no perdamos más tiempo. 00:37:48

que ya bastante he perdido yo antes, hasta queda con esta combinación de armature, ¿vale? 00:38:05

Tenemos este código y lo que vamos a querer, por un lado, es que esto afecte al animator, ¿verdad? 00:38:11

Porque todos los códigos que vayamos poniendo que afecten a este parámetro, por ejemplo, 00:38:19

están dentro del componente animator, ¿vale? 00:38:25

Entonces, yo ya hago una variable que enseguida yo ya digo, yo voy a querer afectar al componente animator de este objeto. Para eso hay que hacer un getComponent del nombre de ese componente, que es el animator, ¿vale? 00:38:28

Con esto ya, por ejemplo, podemos decir que en cierto momento se ponga un set float para, ¿cómo lo hemos llamado? Para caminado. Por ejemplo, para caminado que sea de 1. 00:38:44

¿Vale? 00:39:01

Hasta aquí esto estás entendiendo este código 00:39:05

Lo digo porque 00:39:07

Básicamente, ahora mismo si te fijas 00:39:07

Lo que he hecho es preparar todo 00:39:11

Para que podamos llamar a ese animator 00:39:13

Del objeto que tiene este código 00:39:15

Que por cierto, no lo tengo todavía puesto 00:39:16

¿Vale? Es decir, ahora este script 00:39:19

Va a mirar dentro del animator 00:39:21

Que hay en este objeto 00:39:22

Y así con anim, con esta palabra 00:39:23

Ya podemos acceder a todo lo que hace animator 00:39:26

Y si te fijas 00:39:28

porque es lo que he puesto, no nos hemos preocupado todavía 00:39:30

lo que hace en cada fotograma 00:39:32

es poner un valor float 00:39:34

en uno de los parámetros del animator 00:39:36

que se llama caminado 00:39:39

que coincide con este 00:39:40

y lo pone valor de 1 00:39:42

es decir, cuando arranque el juego, como no hay nada que lo varíe 00:39:44

yo cuando le de aquí 00:39:46

y voy a poner 00:39:47

esto para que se vea en la escena 00:39:49

que se va a ver mejor 00:39:52

perdón 00:39:53

voy a hacer esto un poco más grande 00:39:56

Porque imagino que si no nos vamos a quedar ciegos tú primero, digo de que se están muy pequeñetes. 00:39:58

Vale, y ahora, como esto está en cero y en teoría, según el blend tree que tengo, debería estar quieto, pero como le estoy diciendo que es uno, 00:40:04

¿vale? Por eso le estoy diciendo así a Capón, lo que va a hacer es caminar por defecto. 00:40:11

Yo le doy y el tío no me hace ni caso. Vale, bueno, importante. A ver, se está metiendo aquí. Vale. 00:40:15

Bueno, ves que cuando yo voy cambiando este valor, ¿vale? Sí que se ve que camina el hombre. Vale, vamos a ver por qué no me está cogiendo esto. Esto es un float que se llama caminado. Sí, y quiero que lo ponga en el valor de 1. 00:40:28

Animator 00:40:43

Component 00:40:45

Animator 00:40:47

Está en movimiento personaje 00:40:48

Y debería hacerlo, a ver 00:40:51

Vuelvo a darle, que a veces se le va la pinza 00:40:53

A esto 00:40:56

Vale, ¿por qué puede estar pasando? 00:40:56

Porque de primeras 00:41:00

Según empieza esta condición 00:41:01

Nos metemos aquí 00:41:04

¿Y por qué no lo cambia? 00:41:09

A ver, perdona 00:41:11

Ay, pero es que no 00:41:12

Están pasando cositas 00:41:16

Animator, animator, lo está cogiendo 00:41:18

Float, caminado 00:41:20

Uno, sí 00:41:23

Debería estar perfecto esto 00:41:24

No hay que poner ninguna librería 00:41:26

¿No? 00:41:31

Y esto 00:41:38

Es un float, sí, porque 00:41:39

Tiene decimales, así que sí 00:41:41

A ver, caminado 00:41:43

Caminado, caminado 00:41:45

Caminado 00:41:47

voy a hacer yo que sea otro 00:41:48

probando 00:41:51

adelante 00:41:53

¿vale? estoy diciendo 00:41:55

porque cuando hacemos el blend tree nos lo pone 00:41:57

por defecto, voy a decir que el que 00:41:59

afecte a esto sea el 00:42:01

parámetro 00:42:03

adelante 00:42:04

el parámetro adelante 00:42:06

entonces voy a decir que este es adelante 00:42:09

adelante 00:42:11

y lo guardo y le doy 00:42:13

y a ver ahora 00:42:15

Ahora sí, no sé 00:42:16

¿Vale? Ves que a veces es dar la vuelta 00:42:19

Porque estoy haciendo exactamente lo mismo 00:42:21

Y importante, si te fijas 00:42:23

El personaje no solo no se ha quedado quieto 00:42:25

Sino ves que está avanzando 00:42:27

Lo que te decía antes 00:42:28

Esto es porque la animación ya tiene avance 00:42:30

Claro, esto nos puede interesar en cierto momento 00:42:32

Por ejemplo, si estamos haciendo una película 00:42:35

Y ya tenemos animado al personaje 00:42:37

No va por código, porque también se pueden hacer clips de animación 00:42:38

Aquí 00:42:42

Pero para el juego no nos interesa 00:42:43

Que él vaya cuando quiera 00:42:45

ahí es donde te digo que 00:42:46

hay que decirle, oye, olvida los movimientos 00:42:48

de raíz y tú 00:42:51

te vas a mover por lo que yo te diga 00:42:52

en código, ¿vale? y ves que hace 00:42:54

como una animación pero está en el sitio 00:42:56

¿vale? lo mismo 00:42:58

o sea, que cada vez que haga algo le tengas que dar 00:43:00

tú una tecla, si no se queda parado 00:43:02

¿no? eso es 00:43:04

más que eso piensa que es 00:43:06

que lo que estamos haciendo es 00:43:08

discriminar por un lado la animación 00:43:10

las animaciones de posición 00:43:12

para que no las haga 00:43:14

solo haga las animaciones de las articulaciones 00:43:16

pero que si se desplazan en el espacio 00:43:18

no, eso lo vamos a gestionar 00:43:20

nosotros de otras formas 00:43:22

¿vale? 00:43:24

entonces, ahora mismo por ejemplo 00:43:26

lo que vamos a hacer es decirle 00:43:28

en todo momento 00:43:32

yo no voy a 00:43:34

querer que me pongan uno 00:43:36

lo que voy a querer es que me ponga el número 00:43:38

de lo que yo capte 00:43:39

con un mando 00:43:41

con el teclado, etc. 00:43:45

profundidad, tecla, yo que sé 00:43:47

y aquí lo que voy a hacer 00:43:48

voy rápido y ahora lo vemos 00:43:50

getAxis 00:43:52

y vamos a usar uno de los 00:43:52

axis que ya están configurados 00:43:57

que es el de vertical, ¿vale? 00:43:58

esto sabes de dónde viene, ¿no? 00:44:00

y ahora lo que vamos a decir es 00:44:02

que este valor no sea uno 00:44:04

sino que dependa de que yo esté 00:44:06

activando ese axis 00:44:08

¿vale? es decir, adelante 00:44:09

ahora mismo este valor va a ir 00:44:11

variando según yo pulse o no 00:44:13

ese axis, entonces empieza el juego 00:44:15

y está quieto 00:44:17

y está haciendo una animación de 00:44:19

el idle, ¿no? que es la de que está ahí parado 00:44:21

¿vale? en el momento 00:44:23

y me meto aquí en el juego 00:44:24

pero voy a poner una cámara también o la voy a mover 00:44:26

para que se vea mejor donde está el personaje 00:44:29

porque si no, no 00:44:31

vamos a verlo nunca 00:44:32

a ver, lo voy a poner a menos 180 00:44:34

y en 00:44:37

profundidad ahí le tengo al chico vale yo ahora cuando en el juego le dé a la w ves que pasa de 00:44:39

uno a otro al 1 porque el axis el máximo que da es el 1 vale entonces ahora mismo no se está 00:44:48

moviendo el sitio pero está haciendo esa animación que es lo bueno de esto que si yo por ejemplo lo 00:44:55

estoy haciendo voy a hacer con el translate vale pero lo suyo sería hacerlo con él con fuerza del 00:45:01

RigidBody o con el 00:45:06

o con el CharacterController, ¿vale? 00:45:08

Es más fácil con este, ¿no? 00:45:10

Claro, ahora si quieres vemos 00:45:13

porque aunque parezca más fácil 00:45:14

no es más fácil, ¿vale? Porque 00:45:16

sí que es verdad que 00:45:18

hay veces que no... 00:45:20

A ver, ¿por qué no me coge el Translate ahora? 00:45:22

Translate, ah, vale. 00:45:25

Translate y lo que vamos a decir es 00:45:26

que 00:45:28

haya un nuevo vector 3 00:45:29

y lo vamos a mover en 00:45:32

0, 0 00:45:34

y lo que sea 00:45:35

profundidad tecla 00:45:38

¿vale? con esto 00:45:40

y bueno, acabamos la instrucción 00:45:42

y recordemos que 00:45:44

cuando hay una animación 00:45:46

también hay que lo suyo 00:45:47

ponerle un time delta time 00:45:49

para que siempre sea estable 00:45:52

el movimiento 00:45:53

esto, digo, tú cosas 00:45:55

que vayas, digo que además 00:45:58

como no te he visto en más tutorías pero tú lo que 00:46:00

quieras o hace mucho 00:46:02

de este módulo, de parándome 00:46:03

y veamos, viendo lo que no vayas entendiendo 00:46:06

¿vale? ¿entiendes por qué pongo esto de 00:46:08

Time Delta Time? 00:46:10

Sí, en principio todo el código 00:46:11

que has puesto, sí que lo entiendo 00:46:14

pero yo, si me dan 00:46:15

sin nada, pues 00:46:17

puedo tardar como 00:46:19

15 horas, pero 00:46:21

todo lo que vas poniendo, sí que 00:46:23

porque lo pones, ¿sabes? 00:46:25

Claro, esto es práctica, y es ir 00:46:27

dedicándole tiempo, es decir 00:46:29

y ves que yo también fallo más 00:46:31

que una escopeta de feria, digo que me cuesta 00:46:34

a veces llegar porque es que hay que darle vueltas 00:46:36

es que, claro, porque hay que estar pensando 00:46:38

qué es lo que quieres hacer y 00:46:40

cómo es la lógica y eso es lo que 00:46:42

me cuesta a mí, ¿sabes? 00:46:44

encontrar esa lógica, pero porque no 00:46:46

estoy ahí acostumbrada 00:46:48

pero cuando tú lo haces o cuando lo 00:46:49

hace Álvaro y 00:46:52

sabes, los tutoriales, entonces sí que 00:46:53

digo, claro, o sea, sí, pero 00:46:56

sí, a ver, por ejemplo 00:46:58

lo de cara al examen, en el examen 00:47:00

no va a haber una práctica en ordenador como tal. 00:47:02

Va a haber preguntas tipo test y alguna 00:47:04

desarrollo, pero va a ser en base a cosas 00:47:06

que ya estáis viendo, digamos, ¿sabes? 00:47:08

Lo que 00:47:12

falta aquí es ya 00:47:12

el ponerse, y para eso están las tareas, ¿vale? 00:47:14

Que aunque son voluntarias, 00:47:16

lo que siempre os digo, son muy recomendables porque es donde 00:47:18

se fuerza a 00:47:20

que lo uséis y a que vayáis haciendo el pensamiento 00:47:22

a ir llegando 00:47:24

a las 00:47:26

soluciones. 00:47:28

Espera un segundo, que es que me estoy haciendo un lío con un cable 00:47:29

y yo solo me voy a caer aquí 00:47:32

Dame un segundo, ¿eh? Vale, ah, perdona 00:47:34

Esto es, por ejemplo 00:47:43

el usar un GetAxis 00:47:44

y lo voy viendo a veces en las entregas 00:47:46

Por defecto lo que se suele hacer es usar 00:47:48

un GetKeyDown o algo así 00:47:53

pues para decir, cuando das a la 00:47:54

letra W o cuando das a la S 00:47:57

ya a medida que lo vas usando 00:47:58

y vas haciendo ejemplos como este, te das cuenta 00:48:01

de que el GetAxis es muy potente 00:48:03

en el sentido de que te permite 00:48:05

solo con un input meter un montón de valores 00:48:07

¿vale? por ejemplo esto que te he dicho 00:48:09

nosotros lo estamos haciendo con un teclado 00:48:11

pero este que era axis vertical 00:48:12

si lo hacemos con un joystick 00:48:14

va desde el menos uno hasta el uno 00:48:16

pasando por todos los decimales intermedios 00:48:18

entonces eso da un montón de recorrido 00:48:21

que no se puede con 00:48:23

solo cuando puses una tecla pasa esto 00:48:24

¿vale? 00:48:26

entonces ahora mismo tenemos 00:48:28

que lo que vayamos metiendo por input 00:48:30

se multiplique por este 00:48:32

estabilizador de tiempo 00:48:34

porque es lo que ponía los apuntes y tal 00:48:36

el update según el ordenador 00:48:38

va cargando en un tiempo concreto 00:48:40

lo más rápido posible 00:48:42

entonces si este valor no lo hacemos estable con un time delta time 00:48:43

va a ir dando como tirones 00:48:47

el problema que tiene esto 00:48:48

es que reduce mucho 00:48:50

al multiplicarlo porque los valores 00:48:52

del time delta time que es cuánto tiempo 00:48:54

tarda entre cada actualización 00:48:56

de frame es un 0,0 00:48:58

algo a veces entonces el valor 00:49:01

es pequeñísimo, eso lo que nos obliga 00:49:02

es siempre poner a una especie de multiplicador 00:49:04

que se suele llamar speed, pero se puede llamar 00:49:06

como queramos, lo voy a poner 00:49:08

aquí, speed 00:49:10

para, digamos, remontar 00:49:11

esta caída que ha habido de valor 00:49:14

porque si no se va a mover en décima 00:49:16

esto que va a llegar aquí 00:49:18

va a ser mínimo 00:49:20

entonces 00:49:22

por un lado, vamos a estar 00:49:23

moviendo al personaje con este 00:49:26

translate en profundidad 00:49:28

voy a poner una velocidad de 00:49:30

por ejemplo 10, no lo sé 00:49:32

esto es luego ir probando y poner 00:49:35

el valor que nos sirva para 00:49:37

darle la velocidad que queremos que tenga el personaje 00:49:38

¿vale? pero ahora mismo lo que estamos 00:49:40

haciendo es que estamos cogiendo 00:49:42

el axis 00:49:44

que en el teclado por defecto ¿vale? 00:49:46

esto si lo repaso 00:49:48

también, estos axis 00:49:50

tradicionales 00:49:52

en el input ya viene uno 00:49:53

que se llama vertical, que nosotros podemos 00:49:56

cambiar, pero bueno, por defecto viene 00:49:58

que la W sea el más uno 00:50:00

y la S el menos uno, que normalmente es cuando se juega al juego la cruceta, ¿no? 00:50:02

Pues la tenemos ahí. Evidentemente esto lo podemos ir cambiando nosotros 00:50:07

o en vez de decirle, importante, que coja los valores de un teclado o un botón de un mando, 00:50:11

que lo coja de un eje de un joystick, que es lo que haría Álvaro, en plan, 00:50:20

y en este caso querríamos que lo cogiera del eje Y, ¿vale? 00:50:23

Esto según el mando tiene muchos axis y habría que configurarlo, ¿vale? 00:50:27

Aquí queremos todavía que sea de un ratón o una tecla, pero ahí se configuraría para que fuera entre un valor u otro del Axis. 00:50:31

Y os dejé los apuntes, por ejemplo, en el mando, cada mando tiene una construcción, pero los que son de la Xbox o imitaciones de la Xbox, 00:50:39

aquí te pone a qué se requiere cada uno de estos ejes, ¿vale? Si lo configuráramos como un joystick Axis. 00:50:46

Vale, entonces yo ahora mismo, cuando arranco el juego, va a estar en cero porque no estoy pulsando nada. 00:50:53

Bueno, pero si había cambiado 00:50:58

Ah, bueno, claro, es que he cambiado la cámara 00:50:59

A ver, espera 00:51:01

Quiero, vale, importante, hay un truqui 00:51:03

Para la cámara 00:51:05

Que tenemos aquí con estas coordenadas 00:51:07

Si vamos a 00:51:09

GameObject y ponemos 00:51:10

Move to view 00:51:13

No, move to view no 00:51:15

Align with view 00:51:16

Vale, nos coge la misma posición 00:51:18

Vale, ahí tengo el personaje y está quieto 00:51:21

Esperando, ahora yo cuando doy a la W 00:51:23

¿Ves? 00:51:25

Aunque hay un momento de transición, porque es esto que tenemos aquí de la gravedad, etc. Es cuánto tiempo tarda en ir de un valor a otro cuando pulsamos. Esto se puede ir cambiando la sensibilidad. Vemos que pasamos a caminado y a no caminado. Y ves que casi no avanza. Es decir, está haciendo la animación, pero casi no avanza. 00:51:26

Esto es porque, nuevamente, habrá que subirle la speed bastante 00:51:47

Bueno, aparte de que igual no he guardado directamente 00:51:51

Voy a ponerle 100 00:51:54

Y ahora sí que, por un lado estamos haciendo la animación con el blend tree 00:51:54

Y con otra, bueno, ahora se ha ido a cuenca 00:51:58

Ves que ahora va súper rápido, ¿vale? 00:52:00

Bueno, porque antes seguramente no habría guardado y tampoco hacía falta 00:52:03

¿Vale? Entonces, al personaje lo que habrá que hacer es encontrar ese momento de equilibrio 00:52:06

Sigue siendo muy rápido para la animación que tiene 00:52:10

Dos 00:52:13

A ver 00:52:15

ahí lo tenemos 00:52:17

¿vale? y ahora sí que parece que está 00:52:19

caminando, incluso le doy para atrás 00:52:22

y como no hay animación 00:52:24

a menos uno 00:52:26

se queda en el idle 00:52:27

pero realmente 00:52:29

también podría yo ir añadiendo más 00:52:32

animaciones 00:52:34

en este blend tree 00:52:36

pero dame un segundo que me tengo que sonar los mocos 00:52:37

perdón 00:52:40

va viendo ¿no? lo que vamos haciendo 00:52:40

sí 00:52:46

¿Qué haríamos para cuando queremos correr? Lo que no podemos hacer aquí es hacerlo con un... ¿Cómo se llama? Directamente con el teclado. 00:52:47

Pero lo que sí podemos decirle es que esta profundidad tecla, si además de moverlo, pulsamos, por ejemplo en este caso, decimos Get Key Done, Get Key, no Get Key Done, sino Get Key, mientras estemos pulsando una tecla, que en este caso, por ejemplo, va a ser la del C, yo que sé, mayúsculas, el C Left Shift, ¿vale? 00:52:58

Que es en mayúsculas este que hay debajo del block mayús, ¿no? 00:53:25

Le puedo decir que entonces en ese caso, profundidad tecla, ¿vale? A ver, joven, no me sale, profundidad, bueno, a ver si quiere. 00:53:29

Profundidad tecla, ¿vale? Se multiplique por 2, es decir que profundidad tecla se multiplique por 2, ¿vale? 00:53:45

Bueno, aquí estoy escribiendo cosas que no son. ¿Entiendes qué es esto? Vamos a decirle que el valor de profundidad tecla, mientras estemos pulsando este shift, pase a valer por 2. ¿Sí? ¿Esto lo entiendes? 00:53:55

A ver, repítelo otra vez. 00:54:11

Ahora mismo tenemos una variable que se llama profundidad tecla. 00:54:13

Sí, eso sí. 00:54:15

Vale, entonces aquí le decimos que profundidad tecla pase a valer lo que valga profundidad tecla en este momento, pero multiplicado por dos, ¿vale? 00:54:16

Importante, esto también es que va sirviendo de repaso de cara al examen de los primeros temas. 00:54:26

Esto ya lo hablamos, pero cuando vemos un igual no hay que verlo como un álgebra, que es que los dos lados son iguales y son dos lados, digamos, que tienen que ser equivalentes. 00:54:31

No, aquí significa que a esta variable, siempre lo que pone antes del igual, es que a esta variable lo que pase aquí, ¿vale? 00:54:40

Entonces, aquí lo que estamos diciendo es que esta variable guarde que el valor que tenga se multiplique por 2, ¿sí? 00:54:48

Que esto también en su momento se vio en el tema 1, que también se puede escribir así, de forma simplificada, ¿sí? 00:54:53

Vale. 00:55:01

Esto lo vimos en otra tutoría, hace unos meses. 00:55:02

Entonces, ¿qué ocurre? 00:55:06

le voy a dar aquí 00:55:08

a ver, profundidad 2 00:55:10

¿qué ocurre? que yo por un lado 00:55:12

voy para adelante 00:55:14

y no pulso el shift y hace lo mismo de antes 00:55:16

¿vale? pero si 00:55:18

y ahora lo voy a hacer ¿vale? si le doy 00:55:20

a la mayus, lo tengo pulsada y adelante 00:55:22

vas a ver que de pronto 00:55:24

esto pasa a valer 2 o menos 2 00:55:26

si sigo manteniendo el mayus 00:55:28

y por un lado 00:55:30

al translate como 00:55:32

aquí le está, siempre que estemos manteniendo 00:55:33

esto, ¿vale? Porque si no, esta condición la salta. 00:55:36

Si no, pues es lo mismo que teníamos 00:55:39

antes, ¿no? Se multiplica por 2, 00:55:40

llega el translate y claro, este valor 00:55:43

se moverá hacia adelante, en este caso 00:55:44

en el eje Z, el doble de rápido. 00:55:46

Por eso va más rápido. Pero aparte, 00:55:49

al parámetro adelante 00:55:51

que tenemos aquí, no le pasa un 1, 00:55:52

le pasa un 2. Entonces, 00:55:54

aquí ya sí que hace lo que esté aquí 00:55:56

en el 2 del blend tree. 00:55:58

¿Vale? O sea, que es porque se multiplica 00:56:00

y porque vale 2, o porque solo vale 00:56:03

dos correr claro no aquí lo siempre hay que pensar esto como cajas que guardan valores no 00:56:05

se me dijimos aquí cuando yo pulso la w vale al de estar aquí vale uno pero si yo a esto que vale 00:56:13

uno le añado que si pulso esta tecla ese valor que tengo aquí valdrá el doble vale pero no porque tú 00:56:21

le hayas puesto que correr vale 2 no hay que correr en el sí es decir para que haga esta 00:56:29

animación de run es porque aquí le he dicho que está la haga cuando este valor sea un 2 00:56:36

vale entonces es por eso y porque vale doble no la multiplicas por dos y porque lo has puesto 00:56:40

dos por un lado mira por un lado tenemos lo que es el movimiento real del personaje en el espacio 00:56:50

¿vale? Con este translate, ¿vale? Esto entiendo 00:56:56

que sí. Sí. Y luego 00:56:58

aquí lo que estamos haciendo es cambiar 00:57:00

el valor de este parámetro, ¿vale? 00:57:02

Lo que ponga en el segundo 00:57:04

parámetro que tenemos aquí 00:57:06

en adelante, si le llega un 1, aquí 00:57:08

pondrá un 1 y si le hacemos 00:57:10

para que aquí llegue un 2, aquí pondrá 00:57:12

un 2. Y tú fíjate 00:57:14

que es que todos los blend trees se basan en un parámetro 00:57:15

que en este caso es el de adelante 00:57:18

pero si tuviéramos más, voy a poner 00:57:20

uno de ejemplo. 00:57:22

Podríamos decir que 00:57:25

lo que afecta a esto sea 00:57:26

el parámetro ejemplo 00:57:27

pero claro, es que el que estamos cambiando aquí es adelante 00:57:29

¿vale? vale 00:57:32

entonces, luego, entre aquí lo que vamos a ir 00:57:33

marcando es que animación hay 00:57:36

en el momento en el que este adelante 00:57:37

valga estos valores 00:57:40

vale, vale, vale 00:57:41

y bueno, aparte, la gracia del blend tree es que 00:57:42

en el medio, pues va interpolando 00:57:45

entre las dos animaciones, ¿sabes? 00:57:47

que con un joystick no pasa 00:57:49

de andar a correr 00:57:51

de uno a otro, sino que va 00:57:54

haciendo como en el intermedio va haciendo interpolación mira de hecho si 00:57:55

es que se ve se ve así si yo le doy al play aquí vale esto sirve para hacer la 00:57:59

simulación y yo empiezo a mover verás que aquí empieza a andar un poco pero 00:58:05

cuando llega el uno hace completamente la animación de andado y aquí hace el 00:58:09

intermedio y aquí a medida si tuviéramos un joystick otra vez a medida que vamos 00:58:13

dándole más valor hasta que damos a tope al joystick pues vamos dando esos 00:58:17

diferentes valores, que es la gracia de tener 00:58:22

el axis, ¿vale? que estamos vinculando 00:58:24

las dos cosas, y ojo 00:58:26

que el axis también tiene un 00:58:28

valores 00:58:30

negativos, yo aquí 00:58:32

lo que puedo hacer, no sé si aquí 00:58:34

vienen animaciones de caminado 00:58:36

hacia atrás, ahí hacia 00:58:38

adelante, pero 00:58:40

incluso si hubiera hacia atrás 00:58:42

bueno, no la hay 00:58:44

walk, turn 00:58:48

turn left, no la hay 00:58:49

Pero se podrían ir haciendo más valores y vamos a decirle, vale, esta que sea cuando sea menos uno. Y se pone ahí. Y le voy a decir, simplemente para que se vea, que es andar, pero hacia atrás. Vas a ver que también va... 00:58:54

El pasaje va a parecer que va hacia adelante, pero voy a poner que vaya hacia atrás, ¿vale? 00:59:07

Ahora lo vemos. 00:59:11

Y también le voy a decir que haya otra animación que es de... 00:59:12

No, esta no. 00:59:19

Porque aquí esta nueva que va a ser el menos 2. 00:59:23

Bueno, hay que recolocar todas. 00:59:27

Y esta va a ser el id, el 0. 00:59:29

Esto es 1, esto es 2, que es lo que teníamos. 00:59:33

Esta menos 1 y esta menos 2. 00:59:36

Y esta menos 2, ¿vale? Y entonces aquí vamos a meter la de correr hacia atrás, la de andar hacia adelante, aquí, ¿vale? 00:59:39

¿Y qué va a pasar? Que ahora el personaje va a ir hacia adelante o hacia atrás por este translate que tenemos aquí, ¿vale? 00:59:54

Que cuando es menos 1 va en el eje Z hacia atrás, pero aparte también estamos activando las distintas animaciones. 01:00:01

Es decir, yo ahora voy hacia adelante y cuando voy hacia atrás también como que anda, ¿vale? No es la mejor animación porque sigue haciendo la misma animación que si andara para adelante, pero ves que está pasando entre uno y otro. 01:00:10

Y si yo incluso pulso el shift y doy para adelante, corre, pero si doy hacia detrás, corre para atrás. Lo mismo, no es la animación que haría alguien corriendo para atrás porque no es la que le hemos puesto, ¿vale? 01:00:22

pero ves que va respondiendo a eso sí vale vale más o menos veis cómo funciona algo importante 01:00:31

el blend tree es un nodo aquí vale ya los nodos se llega según las condiciones intermedias entonces a 01:00:41

veces para que se active esto que hay en el blend tree hay que llegar hasta este nodo por ejemplo 01:00:49

Imagínate que yo pongo una 01:00:54

A ver, que sea de agachado 01:00:58

Me parece que había una 01:01:00

Por hacer algo que sea muy exagerado 01:01:01

Esto, ¿vale? 01:01:05

Este personaje también se va a agachar 01:01:06

Y se lo voy a poner 01:01:08

Que esto es importante 01:01:09

Que sea la que hace por defecto 01:01:10

Ahora mismo, digamos que no está conectado 01:01:11

Este blendtree que hemos hecho por ningún lado 01:01:14

Que por cierto, le voy a cambiar el nombre 01:01:15

Para que sea caminado también 01:01:17

¿Vale? 01:01:21

Y ahora en el nodo pone caminado 01:01:23

No hace otra cosa, es para identificarlo 01:01:24

Ahora yo cuando le doy a play 01:01:26

Pues simplemente va a estar agachado el muchacho 01:01:28

¿Vale? Ya está 01:01:30

¿Qué pasa? Que si yo de pronto 01:01:31

Hago lo de que quiero que pase aquí 01:01:34

¿Vale? 01:01:36

Por mucho que yo esté sin pulsar teclas 01:01:38

Estoy diciéndole que esté agachado 01:01:41

Porque es la que va por defecto 01:01:43

O sea, uno entra en el sistema de estados 01:01:44

¿Vale? En el animator 01:01:46

Entonces habrá que hacer una transición 01:01:47

Para que vaya de aquí a aquí con alguna condición 01:01:50

¿Vale? Porque si no 01:01:52

nunca entramos aquí, es decir, para acceder 01:01:54

a lo que estamos configurando 01:01:56

hay que ir siguiendo la lógica de transiciones 01:01:58

¿me vas siguiendo? 01:02:00

Sí, eso también lo había hecho 01:02:02

Vale, lo digo porque en lo que 01:02:04

te he visto que tenías 01:02:06

tenías el idle quieto 01:02:07

pero si quieres 01:02:11

correr y que salte 01:02:13

luego vas a tener 01:02:14

a lo mejor problemas porque si está 01:02:16

corriendo para que salte, bueno, habría que ir 01:02:18

configurando bien los parámetros para que lo hagan 01:02:20

pero que sea consciente de que aunque yo ahora mismo esté quieto y no esté pulsando nada bueno 01:02:22

ahora lo ha hecho porque cuando acaba de hacerlo una vez hace esta transición porque no le hemos 01:02:28

puesto ninguna condición hace esta animación y va hacia aquí vale pero que para que haga este 01:02:32

el estar quieto yo estoy quieto y ves que primero hace entera está y luego pasa a la siguiente si 01:02:37

aquí pusiéramos una condición que no se cumple por mucho que aquí configuremos un blend y no 01:02:42

llegaría al blendtree sí vale más o menos si para seguir avanzando lo ves si más dudas que tengas 01:02:46

si no te enseño un par de cosas del que tenía yo preparado vale si te enseño yo si nada simplemente 01:02:56

como referencia de qué cosas se pueden conseguir vale de bueno voy a guardar este y hablo del otro 01:03:03

De esto 01:03:09

Digo, más o menos te queda claro 01:03:13

Lo que estamos haciendo 01:03:16

Vale, vamos allá 01:03:17

Bueno, lo guardo 01:03:19

Este no me sirve para otra cosa 01:03:20

Pero tenía aquí yo uno 01:03:22

Por ejemplo este 01:03:24

Las prácticas, sobre todo en Dane 01:03:25

Lo que más me importa es 01:03:32

Que os pongáis a hacerlas y vayáis superando obstáculos 01:03:34

¿Vale? Porque por eso pongo 01:03:37

Ya en estas últimas tantas 01:03:38

Cosas opcionales 01:03:40

digamos, porque 01:03:42

es que hasta que no, por mucho que lo leáis 01:03:44

y 01:03:46

y lo 01:03:48

a ver, espera, ¿cuál era? 01:03:49

por mucho que lo veáis y veáis vídeos 01:03:52

etcétera, evidentemente tenéis que verlos 01:03:54

para saber, hasta que no os ponéis a hacerlo 01:03:56

no lo hacéis, ¿sabes lo que te quiero decir? 01:03:58

entonces... si no lo comprendes 01:04:01

claro, es que por mucho que digas 01:04:02

ya sé hacerlo, hasta que no lo haces 01:04:04

no te sale, no, si, si, es verdad 01:04:06

y es que eso yo no puedo hacer nada más allá 01:04:08

de que hagáis las prácticas 01:04:10

y me preguntéis en base a ello 01:04:11

simplemente, ahora vemos si quieres 01:04:13

cómo está hecho, para que tengas 01:04:16

una referencia, pero este es el juego 01:04:18

si se cumpliera todo lo que hay en él 01:04:19

salta, hace diversas 01:04:22

cosas, el juego 01:04:24

tiene cosas mejorables, pero bueno, ya tiene un montón de cosas 01:04:25

que es lo que pide el enunciado 01:04:28

si se completara todo 01:04:30

al menos los mínimos 01:04:31

que es que hay personajes que te siguen 01:04:33

el movimiento del personaje, incluso hay 01:04:35

una mira, por si queremos 01:04:38

apuntar una pistola 01:04:39

¿vale? entonces 01:04:41

esto es ir poco a poco 01:04:43

lo de siempre, el terreno 01:04:45

por lo que me has contado, pues aquí 01:04:47

es un terreno que está generado 01:04:49

¿vale? y tenemos 01:04:51

aquí un personaje, que es este, pero podría 01:04:53

ser el que tú tienes ¿vale? que 01:04:55

tiene un animator 01:04:57

nuevamente con un avatar y 01:04:59

en ese animator pues hay un montón de estados 01:05:01

¿vale? y aquí 01:05:03

si no me equivoco 01:05:05

por lo que sea 01:05:06

En el zombie sí que hay 01:05:10

Pero aquí no hay un blend tree 01:05:12

Si te fijas, ah sí, este sí que es un blend tree 01:05:14

Mira 01:05:16

Tenemos un blend tree 01:05:17

Según entra, ¿vale? 01:05:21

Que lo que hace es, si te fijas y le clico aquí 01:05:23

¿Vale? Es de una dimensión 01:05:26

Porque en el vídeo también se deja caer que hay de más dimensiones 01:05:27

Que esto es para que incluso 01:05:30

Si no solo es hacia adelante y hacia atrás 01:05:32

Sino que también quieres que el personaje 01:05:34

Cuando vaya en diagonal 01:05:36

Junte la animación, por ejemplo 01:05:37

Lo estamos dando a la W y a la D, ¿no? Que es hacer la diagonal. Sirve para que, digamos, interpole las animaciones de ir hacia adelante, si pulsamos la W y de ir a la derecha, si lo hemos configurado para ir a la derecha con la D, ¿vale? 01:05:39

Entonces con eso se pueden hacer ya como ejes de en plan combinar dos parámetros, ¿vale? Está más complicada, pero lo bueno es que ya según vas haciendo que el personaje por un lado en dos ejes vaya hacia adelante o hacia la izquierda, ir poniendo animaciones, ¿vale? 01:05:55

Pero bueno, vamos a quedarnos de momento en esta. Y a ver, que yo creo que... A ver, un segundín, que creo que me he cargado algo, por eso sale este error. Vale. A ver, funciona bien. Vale, perfecto. Vale, entonces, por defecto, cuando yo entro en el personaje, ¿vale? Estoy con el personaje, se mete aquí y se queda ahí, ¿vale? En este nodo de estado. 01:06:12

y este nodo de estado es un blend tree 01:06:37

¿y cómo he configurado yo ese blend tree? 01:06:39

yo quería que este personaje, que también lo pone como propuesta 01:06:41

aparte de ir hacia adelante 01:06:44

y rotar, ¿vale? con la cruceta típica 01:06:46

con la Q y con la E 01:06:48

pueda moverse lateralmente, es decir 01:06:49

puedo hacer esto, yo le doy a la Q 01:06:51

¿vale? y ves que hace una animación de lateral 01:06:53

no de rotar, que es lo que hace cuando 01:06:55

doy a las flechas, sino lateral 01:06:58

entonces, yo el idle 01:06:59

lo aproveché 01:07:01

de hacer un idle, si está en el 0 01:07:02

Pues el chico está tranquilo, ¿vale? Y puse un axis que son los límites, la Q y la E, ¿vale? Si yo me meto en el player controller y este movimiento lateral se llama strafe, ¿vale? Así como pone aquí, en este strafe yo lo que hice es ponerle un axis que creí yo que se llama strafe, ¿vale? 01:07:06

Y nuevamente yo fui aquí a los Project Settings y hice un nuevo axis que es Strafe, ¿vale? Que tiene la Q como negativo y la E como positivo, ¿vale? Y eso es con lo que consigo que vaya, como hemos hecho antes, ¿vale? Que vaya hacia izquierda o hacia derecha. 01:07:27

Lo bueno en este caso con Mixamo es que yo he sacado la animación para ir hacia la izquierda y hacia la derecha. 01:07:43

Entonces, dependiendo de qué voy pulsando, este parámetro que yo he puesto, estrafe, es el que yo voy cambiando aquí más adelante. 01:07:54

Este código ya tiene bastante, pero voy haciendo lo mismo. 01:08:04

Pongo un float que es el valor de ese axis, ¿vale? Solo que me está cambiando ese parámetro que se llama estrafe, que es al que yo le he vinculado, podría vincularlo a otro. Entonces con eso he conseguido que por defecto esté quieto y si doy a las otras dos teclas de Q y E voy hacia los laterales. 01:08:07

Pero luego ya para ir hacia adelante, incluso correr o ir hacia atrás, son nodos distintos con su propia animación. Sí que en caminado, por ejemplo, también he puesto, aunque este realmente no es muy necesario, otro por si queremos dar sensibilidad, que este esté asociado al caminado. 01:08:27

Pero este, la verdad es que se podría haber puesto solo la animación con uno normal, tampoco hacía falta blend tree, porque con ir hacia adelante y que algo sea mayor que el valor de 0.1, que tengo aquí y que tengo vinculada al axis de vertical, pues ya iría hacia adelante. 01:08:50

no sé si me sigues 01:09:08

y luego si yo 01:09:10

estoy caminando hacia adelante 01:09:13

si aparte yo pulso 01:09:14

una tecla que activa 01:09:17

una booleana 01:09:19

que es run, pues pasará al estado de run 01:09:20

que es un poco lo que hemos hecho antes pero 01:09:23

en vez de hacerlo todo en un solo blend tree 01:09:25

lo he hecho en distintos estados 01:09:27

vale, o sea que es como 01:09:28

lo he dividido 01:09:30

en vez de hacerlo todo en uno junto 01:09:32

lo he ido dividiendo 01:09:35

que es la gracia de esto 01:09:36

que aquí puedes poner muchas animaciones 01:09:38

solo 01:09:41

y valores intermedios en un solo nodo 01:09:42

y hacer lo mismo que tú 01:09:45

en todos los 01:09:46

esto como lo que has hecho tú es como más lioso 01:09:48

eso es, y hay que poner más condiciones 01:09:50

más 01:09:53

tú fíjate, ahora está la de quieto 01:09:53

yo si doy a la Q y a la E 01:09:57

sigo en el mismo nodo porque 01:09:58

está en el blend tree, si yo me pongo 01:09:59

a caminar, fíjate que lo que hace es pasar 01:10:02

al nodo de 01:10:04

caminado, que yo le doy al 01:10:05

creo que es al shift, sí, vale 01:10:08

pues se está activando, si te fijas aquí 01:10:10

una booleana 01:10:12

de RAM, mientras yo lo tengo pulsado 01:10:14

y estoy ahí, cuando suelte 01:10:15

esa booleana se desactiva y la condición 01:10:18

que tengo es que si este RAM pasa 01:10:20

a ser falso, pues yo voy a walk otra vez 01:10:22

y bueno, como he dejado de moverme 01:10:24

y 01:10:26

el parámetro de walk es 01:10:27

menor a 0.1, es decir que estoy quieto 01:10:30

pues vuelve a estar aquí en reposo 01:10:32

Luego, por ejemplo, tengo una tecla, si vamos al código un segundo, tengo una tecla que es que si yo pulso el control, a ver dónde lo tengo, si yo pulso control, si yo pulso barra espaciadora, pues tengo un método que es saltar, pero vamos un segundo al control. 01:10:34

Si pulso la letra control, se aplica este método, ahora lo vemos, que he hecho yo, que se llama desenfundar. Y si suelto, son acciones que son o pasa una o pasa la otra. Si suelto esa misma tecla, enfunda. Por eso es la diferencia de cuando yo pulso desenfunda y cuando dejo de pulsar este app, pues se enfunda. 01:10:56

entonces desenfundar 01:11:21

yo es un método que he hecho aquí 01:11:24

y aparte de cambiar la cámara de Cinemachine 01:11:26

etcétera, lo que hago es 01:11:29

que hay un trigger que es el de 01:11:31

aim, que es el de 01:11:33

apuntar, ese trigger 01:11:34

que es que según pulsas pasa algo 01:11:36

yo lo tengo aquí configurado para que en cualquier 01:11:38

momento, sin tener que 01:11:41

pasar por otro, porque aquí es verdad 01:11:42

que tú no puedes ir de este nodo 01:11:44

a este si no pasa antes por walk 01:11:47

¿vale? 01:11:49

Pero aquí yo he configurado que en cuanto haya el trigger llamado aim, que ves que no es una booleana, no es que se quede marcada o no, bueno, aquí se queda marcada, pero mientras jugamos, cuando yo pulso se desencadena una vez ese aim y paso a esto, porque es un trigger que lo que hace es funcionar una vez como para desencadenar una acción, ¿vale? 01:11:49

Ahí lo que hago es que de pronto aparece una geometría que tengo una pistola en la mano, luego posteriormente el booleano apuntando pasa a ser true, ¿vale? Y yo le doy y lo que hace es que entonces ya está la condición que hay aquí para que pase a enfundar o desenfundar. 01:12:11

porque yo cuando esto 01:12:33

pasa a ser apuntando 01:12:35

positivo, se queda aquí 01:12:37

y en cuanto yo suelte con el 01:12:39

enfundar, esto le digo 01:12:41

que sea falso, entonces ya 01:12:43

le doy la condición para que pase 01:12:45

de aquí a aquí y de aquí a aquí 01:12:47

y vuelva a estar en el estado normal 01:12:49

¿sí? 01:12:51

sé que es lioso y que son muchas cosas 01:12:53

pero esto es lo que hay que ir pensando que se va 01:12:55

haciendo, claro, ¿vale? entonces yo 01:12:58

le doy, estoy enfundando, yo me puedo mover 01:12:59

etcétera, girar, ¿vale? eso no lo he bloqueado 01:13:01

pero en cuanto suelte 01:13:04

ese getKeyUp, el control 01:13:05

esto va a dejar de ser positivo 01:13:07

se cumple esta condición, se guarda 01:13:09

esa animación que tiene y ahora 01:13:11

pues ya empieza a andar otra vez 01:13:13

vale 01:13:15

vale, entonces 01:13:16

eh 01:13:19

sí, más o menos 01:13:20

a ver aquí, borra algo, más o menos 01:13:23

sé que hay muchas cosas 01:13:25

y luego, ¿por qué? por ejemplo 01:13:27

se usa en este caso 01:13:29

en vez del translate, por ejemplo 01:13:30

se usa el character controller 01:13:33

cuando estás trabajando en un 01:13:35

terreno que es un plano 01:13:37

pues no pasa nada, porque tú estás 01:13:38

moviendo un personaje hacia adelante y hacia atrás 01:13:41

y no pasa nada, pero ¿qué pasa 01:13:43

si tú estás haciendo, como en este tipo de juegos 01:13:45

un terreno que tiene 01:13:47

pendientes? 01:13:49

Ah, vale, que las traspasas, ¿no? 01:13:51

Claro, tú lo que... 01:13:53

la gracia que tiene es que tú puedes decirle 01:13:55

hasta dónde subes, porque 01:13:57

si te fijas, el componente 01:13:59

carácter control ya está configurado 01:14:01

para cosas como límite 01:14:03

de cuestas, o si hay peldaños 01:14:05

pues que lo supere, claro 01:14:07

tú si estás diciendo que un objeto vaya para adelante 01:14:09

y hay un escalón con su collider 01:14:11

pues se queda ahí pillado, no tira 01:14:13

para adelante, esto lo que permite es 01:14:15

¿ves? aquí la pendiente es mayor de 45 grados 01:14:17

ha subido hasta ahí 01:14:19

¿vale? pero ya no sube, si yo le digo que 01:14:21

el límite sean, pues voy a poner 180 01:14:23

¿vale? vas a ver 01:14:25

que ya el personaje sí que sube eso no se puede con el transforma menos que le des un montón de 01:14:27

vueltas vale entonces el juego del mundo abierto pues es la forma digamos ya optimizada para hacer 01:14:33

estos comportamientos tiene más cosas vale pero sobre todo esto también tiene una detección de 01:14:39

piel distinta bueno tiene otro tipo de parámetros vale si yo ahora mismo le digo pues eso que 45 no 01:14:44

bueno, se caerá, pero yo ya 01:14:54

por aquí no puedo subir 01:14:56

¿vale? por mucho que me empeñe 01:14:57

¿vale? 01:15:00

esa es una de las razones para usar el carácter 01:15:02

controller, por ejemplo 01:15:04

más cosas 01:15:05

lo que me has dicho de la pistola en este caso 01:15:08

de las geometrías que se vinculan con 01:15:10

una animación o algo así, ¿no? 01:15:12

ah, sí, eso 01:15:14

lo pone 01:15:15

a ver 01:15:16

mira, fíjate en una cosa 01:15:21

a ver si es esto, o bueno 01:15:24

si sabes el punto concreto del tema 01:15:26

lo vemos, pero creo que se refiere a esto 01:15:28

Sí, creo que era por ahí, sí 01:15:29

Claro, tú cuando sacas de Mixamo 01:15:31

una animación 01:15:33

con su esqueleto 01:15:35

o bueno, o no de Mixamo, que lo has hecho tú 01:15:37

el rigging en un software 3D 01:15:39

o te has bajado una animación de internet, ¿vale? 01:15:41

aunque no se haya hecho con Mixamo 01:15:43

tú tienes aquí esta geometría 01:15:44

entonces tú lo que puedes hacer es buscar, por ejemplo 01:15:47

si te fijas aquí 01:15:49

a ver, en escena 01:15:50

tenemos todas las partes del cuerpo 01:15:52

Yo las puedo ir marcando y ves que cambia dónde está la posición de ese elemento, ¿no? De la mano, del brazo, ¿vale? En el rigging funciona así. 01:15:55

Entonces, aquí, por ejemplo, si yo quiero añadir este personaje, por defecto, no viene con esta pistola. Mira que la desactivo y ves que la pistola desaparece y aparece, ¿vale? 01:16:03

Entonces, lo que se puede hacer es hacer hijo un elemento de otra geometría para que se mueva con ese objeto. 01:16:12

Ahora mismo, en cuanto a la mano, ¿vale? Porque está vinculada a la mano. Se mueva, vas a ver... Bueno, de primera es el que está oculta la pistola. Solo la saca, ves que la ha sacado ahí y ves que se está moviendo con la mano. 01:16:21

Pues si tú la asocias y la pones en una posición, por eso de que al emparentar y hacer hijos un objeto de otro, coge sus posiciones, ¿vale? A ver, que aquí ha habido un pequeño bug, ¿vale? 01:16:34

Pues estamos adjuntando geometrías. ¿Qué es lo que he hecho? Que cuando yo se hace la animación esta de enfundar, se oculta esa pistola. Fíjate que yo cuando desenfundo, ¿vale? Tengo aquí un método, primero que la pistola, ¿vale? Que es este GameObject, que yo tengo aquí metida la pistola, ¿vale? 01:16:45

Yo aquí he hecho una variable pública que es esta pistola y la he arrastrado ahí. 01:17:09

Y entonces yo ya puedo decir que ese objeto se haga activo o no. 01:17:14

Cuando yo desenfundo y le doy al control, a ver si me deja porque me está atacando, 01:17:17

esa se hace activa y se ve. 01:17:22

Cuando desenfundo se oculta. 01:17:24

¿Por qué? Yo tengo aquí otro método que lo que hace es hacer que este objeto de pistola pase a no ser activo. 01:17:26

Entonces, lo que dirá es que, claro, tú si esta pistola la metes dentro de la mano, pues se va a ver raro porque está dentro de la mano. O si la animación, por ejemplo, hiciera que se rasca la cabeza y le pones la pistola, pues la pistola se metería en la cabeza, ¿vale? 01:17:33

Sí. 01:17:50

Entonces, entiendo que se refiere a eso. ¿Sí? ¿Te cuadra con lo que has leído? 01:17:51

Eh... 01:17:57

¿O se refería a otra cosa? Digo que... 01:17:57

Aquí pone que no puedes cambiar la jerarquía añadiendo el arma en la mano, ni borrar mallas. 01:17:59

Claro, por mucho que yo tenga... 01:18:08

Esta pistola es un elemento independiente del personaje. 01:18:10

Si tú empiezas a meter objetos en mitad, te puedes cargar la estructura de esqueleto. 01:18:12

Entonces siempre lo suyo es ponerlo al final de una de las ramas. 01:18:20

Vale. 01:18:22

Vale, porque si no, tú ten en cuenta que si de pronto metes algo que entre Right Solder y Arm, todo lo que hay dentro ya no está teniendo ese orden que detecta el avatar, ¿vale? Ese avatar, ese constructo que hay de huesos que te he enseñado antes que salí aquí, bueno, lo tengo por aquí. 01:18:23

Espera, que tendría que buscarlo, pero vamos 01:18:42

El avatar que es 01:18:44

Pues en el caso del zombie 01:18:45

Por ejemplo, este 01:18:48

Pues esto, ¿sabes? Si tú empiezas a meter elementos 01:18:49

Que ya no se cuadran con 01:18:52

Porque esto al final son 01:18:54

Como si yo arrastro estos 01:18:55

Estas posiciones, ¿vale? 01:18:57

Esta distribución de elementos 01:18:59

Al final hay que ir haciendo que respete 01:19:02

Porque es lo que hace que el software 01:19:04

Cuando vas haciendo las animaciones 01:19:06

Al abrir una animación cualquiera 01:19:07

Tú tienes aquí estos elementos 01:19:10

también, y bueno, este justo 01:19:12

no tiene mucha animación, pero 01:19:14

que la animación se basa en qué punto 01:19:15

de cada elemento es el que se tiene que mover 01:19:18

si tú no lo estás vinculando bien 01:19:20

no lo estás ajustando bien, pues 01:19:22

no lo va a respetar, claro 01:19:23

¿vale? 01:19:25

Sí, aquí pone que se puede hacer 01:19:26

otro prefab pulsando 01:19:29

el botón derecho al FBX 01:19:31

de la jerarquía y marcar prefab 01:19:33

un pack 01:19:36

complete y dejará de ser 01:19:37

dependiente del 01:19:39

fx original vale eso mira por ejemplo vamos aquí a ver no tenía yo a este hombre cuando tienes tú 01:19:40

un fx a ver tengo que buscar a este survivor y aquí tengo survivor cuando tienes un fx 01:19:52

Tú al meterlo aquí 01:20:03

Fíjate que tienes 01:20:07

Y además lo tienes marcado azul 01:20:09

Como si fuera un prefab 01:20:11

Un montón de cosas vinculadas 01:20:12

¿Vale? 01:20:16

Porque dentro del paquete FBX 01:20:16

Tenemos también estas tres estructuras 01:20:18

Que si te fijas, cada una es una cosa 01:20:20

Por ejemplo, aquí son tres elementos 01:20:23

Y yo, si quiero sacar 01:20:24

La mochila 01:20:27

Que ves que es un elemento independiente 01:20:29

Está dentro del personaje 01:20:30

pero no está rigueada 01:20:32

porque la mochila de hecho no tiene animación 01:20:34

me refiero, la mochila va siguiendo 01:20:37

donde esté el personaje, pero lo que tiene animación 01:20:39

de que mueva brazos y tal 01:20:41

es el personaje, la mochila no está rigueada 01:20:42

entonces yo si quiero sacar la mochila 01:20:44

no te deja 01:20:47

porque está dentro de este paquete 01:20:48

igual yo quiero tener la mochila porque de pronto 01:20:50

desaparece el personaje y tal, ves que no me deja 01:20:52

entonces esto se puede hacer 01:20:54

o arrastrando 01:20:56

ves que aunque yo arrastre 01:20:57

solo el backpack, borro 01:21:00

yo cojo este backpack y digo, ah mira, tengo esta geometría 01:21:02

la voy a meter aquí 01:21:04

aquí, entre las cámaras 01:21:06

y ves que lo que hace es meterme a todo el personaje 01:21:08

tengo todo otra vez 01:21:11

tengo ahí un personaje entero 01:21:12

y otra vez, digo, no, yo solo quiero la mochila 01:21:13

no me deja, que lo que hay que hacer, desempaquetar 01:21:16

cogemos este elemento 01:21:19

y en prefaz decimos desempaquetar por completo 01:21:20

y ahora ves que ya no 01:21:22

está vinculado con ese azul 01:21:24

y ahora la mochila, yo ya puedo borrar este personaje 01:21:26

y tengo la mochila solo 01:21:28

Bueno, es que este es el otro que he metido 01:21:30

Vale 01:21:32

O sea, esto es como para solo 01:21:33

De ese paquete solamente aislar 01:21:36

Una cosa que tú quieras y ya está 01:21:38

Y colocarla luego donde quiera 01:21:40

Se refiere incluso a esto, ¿vale? 01:21:42

Para desempaquetar tiene que estar dentro 01:21:44

Del juego 01:21:46

Pero eso, si tienes un FBX con muchos 01:21:47

Elementos o muchas partes 01:21:50

Porque un FBX al final es un formato que admite 01:21:52

Meter un montón de cosas 01:21:55

Dentro, o varias geometrías, como ves aquí 01:21:56

asociadas, ¿vale? Pero está todo dentro 01:21:58

de un paquete, está leyendo solo un único 01:22:00

archivo, que es este FBX. 01:22:02

Si queremos independizar las geometrías 01:22:04

hay que hacer este 01:22:07

un pack, ¿vale? 01:22:07

Vale. A eso se refiere. Vale, vale, vale. 01:22:10

Es que así 01:22:13

leído no lo entendía. 01:22:13

Ya, no, no, sí. Si es que hay cosas que 01:22:16

es complicado, que yo lo entiendo, ¿eh? 01:22:18

Pero bueno, para eso me podéis 01:22:20

preguntar también. Vale. 01:22:22

Más cosas. 01:22:24

Yo ya estaba, porque es que como 01:22:26

no ha llegado a más, pues... 01:22:28

Vale. 01:22:30

Eso, 01:22:33

si usas el Character Controller, 01:22:34

importante, para que tenga 01:22:37

gravedad, lo pone en los apuntes, 01:22:38

pero es de esas cosas que 01:22:40

si no, no se ve. 01:22:42

Mira, voy a meter... 01:22:44

Mira, voy a ocultar este personaje que tengo, 01:22:46

¿vale? Y voy a meter otro, simplemente 01:22:48

para que lo veamos rápido. 01:22:50

Si metemos a este Survivor 01:22:52

y lo meto 01:22:54

y lo voy a meter ahí 01:22:56

en esta parte, ¿vale? 01:22:58

Y lo voy a levantar, ¿vale? 01:23:00

Cuando metes un... 01:23:02

Claro, otra de las cosas que me has dicho 01:23:04

es más fácil un translate. El problema 01:23:06

es que el translate no aporta gravedad. 01:23:08

Sí, eso te iba a decir 01:23:10

que luego con el... 01:23:12

que cuando has empezado a subir montañas 01:23:14

digo, pues si ya no hay que 01:23:16

poner ni gravedad ni nada. Eso es. 01:23:18

Eso ya lo viene todo 01:23:19

junto y estaba mirando todo 01:23:22

lo que se estaba moviendo y digo 01:23:24

pues ahí no viene nada de poner nada. 01:23:26

No hay Rigidbody, por ejemplo. 01:23:28

Sí, sí, sí, claro, exacto. 01:23:29

Vale, eso, la gracia que tiene el Character Controller, 01:23:31

se lo agrego a este nuevo que he metido, 01:23:34

Character Controller, 01:23:36

es que por defecto tiene ya como una especie de cápsula 01:23:37

que hay que ajustar, ¿vale? 01:23:40

Vale, que esto hay que hacer que se ajuste bien, 01:23:42

pues yo qué sé, la altura más o menos está bien, 01:23:45

pero el center en Y, no. 01:23:47

Pero voy a hacer más grande esto para que se vea mejor, 01:23:49

que si no, no ves. 01:23:52

¿vale? y lo he puesto 01:23:53

sobre todo lo más importante es que se ajusta 01:23:55

a los pies ¿vale? a la forma de la silueta 01:23:57

yo que sé, para que lo veamos 01:23:59

aquí ¿vale? y aquí cuando yo 01:24:01

le doy al play no pasa nada 01:24:03

vas a ver que se queda ahí en volandas 01:24:04

¿vale? esto lo ponen 01:24:06

los apuntes ¿vale? pero es verdad que hasta que no se hace 01:24:09

igual cuesta, pero 01:24:11

eh... 01:24:12

Character Controller tiene, hay que hacer 01:24:14

un script, tiene varios métodos 01:24:17

que tienen cosas asociadas 01:24:18

me refiero, tiene 01:24:21

Y lo vas a ver en los ajustes, en los apuntes. Hay como dos formas de mover básicas en el Character Controller a un personaje. Character Controller Explicación, yo qué sé, voy a llamarlo así. Y le voy a juntar este script al personaje del Survivor nuevo, ¿vale? Ahí lo tengo. 01:24:22

Cuando nos metemos aquí, sí, y vas a ver que, bueno, lo mismo, para poder afectar a los parámetros y a las posibilidades que tiene un componente CharacterController, lo primero que hay que hacer es, le llamamos cc, es coger ese CharacterController, acceder al componente, ¿no? Con ese GetComponent, ¿sí? 01:24:39

Lo mismo que hemos hecho antes, pero en este caso con carácter controller, porque si no, no podemos acceder a las propiedades que tiene, ¿vale? 01:25:00

Y sin yo hacer más, en el update, ¿vale? Para que se vaya refrescando, hay una forma de mover a los personajes que se llama simple move, ¿vale? 01:25:07

El simple move te va a pedir unas coordenadas de movimiento y yo, por ejemplo, voy a poner solamente una vacía, ¿vale? 01:25:16

Que es un vector 3, 0, ¿vale? 01:25:25

Esto, no sé si sabes lo que es. 01:25:28

Esto es como un vector 0 es como hacer un nuevo vector 3 01:25:35

que sea así, 0, 0, 0, ¿vale? 01:25:41

Ahora mismo no se va a mover. 01:25:44

Simplemente estoy poniendo algo como para que veas 01:25:46

que incluso aunque no se mueva y no se pase nada más, ¿vale? 01:25:48

Al usar este método vas a ver que ya una de las cosas 01:25:51

que tiene, a ver, espera, lo guardo 01:25:54

una de las cosas que tiene 01:25:56

es que, ¿ves que el personaje ya ha caído? 01:25:58

Sí. ¿Vale? 01:26:03

Voy un segundo 01:26:05

que me parece interesante 01:26:05

un segundo, vamos a ir 01:26:07

un poco a los apuntes para que veas también 01:26:09

cómo interpretar eso, aunque lo explica Álvaro 01:26:11

más o menos ya en el 01:26:13

en su vídeo, pero en, a ver 01:26:15

joder, vale 01:26:18

tengo que ir al aula virtual 01:26:21

un segundete 01:26:23

voy a abrir los apuntes de este tema 01:26:25

vale, tema 6 01:26:27

y si vamos a la parte de los 01:26:33

CharacterController 01:26:35

bueno, os he puesto 01:26:36

bastantes recursos 01:26:39

vale, pero aquí te pone 01:26:41

que este componente tiene varias características 01:26:42

propias, se moverá 01:26:45

solo cuando lo llamamos al 01:26:47

SimpleMove y Move, cuando ponemos 01:26:49

solo referido a 01:26:51

que estemos usando ese componente 01:26:52

de CharacterController 01:26:55

SimpleMove, te lo pone 01:26:56

lo que no permite es hacer saltos 01:26:59

es un método que en este 01:27:02

aunque te pida aquí 01:27:04

un vector 3 de movimiento 01:27:05

igual que en el translate 01:27:07

que metíamos los 3 ejes para ver hacia donde se movía 01:27:09

el eje Y, el de salto, lo omite 01:27:12

¿por qué? porque lo que va a estar haciendo 01:27:16

siempre es que el personaje 01:27:18

va a estar cayendo hasta que encuentre 01:27:20

un objeto con un collider que le detenga 01:27:22

¿vale? 01:27:24

esto es porque hay muchos juegos 01:27:26

Que realmente los personajes no saltan 01:27:27

Solo se van desplazando por el espacio 01:27:30

Y quitarte, si va a ser así el juego 01:27:31

Y no salta, quitarte todo lo relacionado 01:27:34

Con el eje y simplifica mucho las cosas 01:27:36

¿Vale? 01:27:38

Porque ya te mete la gravedad 01:27:39

Te va metiendo más 01:27:41

Posibilidades 01:27:44

O te limita 01:27:47

Digamos, en tuertos que puedes tener 01:27:48

Perdona un segundo que tengo que 01:27:50

Sonarme los mocos, perdón 01:27:52

Por cierto, acabo de ver que hay otra compañera 01:27:54

se ha metido, que no la he saludado 01:28:03

ni la había visto 01:28:05

hola, sí, digo, me metí al principio 01:28:05

llevo escuchando todo el rato 01:28:09

¿ah, sí? joder, pues sí 01:28:10

pues estoy aquí 01:28:12

estás agazapada 01:28:14

estoy intentando 01:28:16

ponerme al día un poquito 01:28:19

vale, pues 01:28:20

¿qué estaba diciendo? 01:28:22

vale, eso, el simple move 01:28:25

lo que hace es que obvia 01:28:26

este eje 01:28:28

digamos que siempre lo deja 01:28:31

como si no existiera 01:28:32

¿vale? y eso es lo que significa 01:28:34

esto que estamos viendo aquí de 01:28:36

pues eso, a ver 01:28:38

que no puede saltar, ¿no? 01:28:42

sí, pero por aquí pone, por ejemplo, usando el método move 01:28:45

que es más complejo y ese sí que 01:28:48

permite usar 01:28:50

digamos 01:28:52

el eje Y en posición de reposo 01:28:53

no tiene gravedad y se la tenemos que añadir nosotros 01:28:56

es decir, cuando usamos 01:28:58

Y aquí un ejemplo de uso. Cuando usamos el simple move, no hace falta decir nada de gravedad porque ya la tiene por defecto, pero si luego en el ejemplo que ponemos después usamos un move, la gravedad hay que simularla todo el rato con parámetros que está añadiendolo. 01:29:00

Y otra cosa que tiene buena el Character Controller es que tiene un parámetro, una opción 01:29:16

Que es este IsGrounder, que lo que hace es que devuelve una booleana de si está este Collider que tenemos aquí 01:29:28

Que no es un Collider, pero es básicamente el área en el que se restringe el Character Controller 01:29:37

hay en todo momento una forma de comprobar 01:29:42

si esto está tocando el suelo 01:29:45

o otro collider, vaya 01:29:47

si nosotros por ejemplo 01:29:48

queremos que el personaje salte 01:29:51

vamos a querer que salte siempre 01:29:52

que esté tocando el suelo 01:29:54

a menos que tengamos un juego que permita hacer dobles saltos 01:29:56

o algo así, pero no es posible saltar 01:29:59

si no estás apoyado en algo, ¿verdad? 01:30:01

entonces, este 01:30:03

mira, me abro el código que tenía yo antes 01:30:05

este character controller 01:30:07

lo que permite por ejemplo es 01:30:10

a ver, que 01:30:12

si, ves que 01:30:14

bueno, aquí es la variable que he recogido 01:30:17

el carácter controller, si comprueba que está 01:30:19

aterrizado, que está tocando 01:30:21

suelo, ahí es donde entonces si puedo 01:30:23

llamar al trigger de jump 01:30:25

¿vale? y se ejecuta, si no, no 01:30:27

porque si no, es lo que me impide 01:30:29

que yo cuando le dé a la barra espaciadora 01:30:31

varias veces 01:30:33

a ver, espera, claro, es que tengo oculto 01:30:33

ese personaje, voy a ocultar este que 01:30:37

estábamos haciendo un segundo 01:30:39

y lo ponemos aquí, ¿vale? 01:30:40

cuando tenemos este personaje 01:30:42

es lo que impide que yo, aunque le dé 01:30:44

varias veces a la tecla 01:30:47

de saltar, hasta que no se vuelva a posar 01:30:49

no me deja 01:30:51

saltar más veces, y de hecho 01:30:53

fíjate que aquí hay un 01:30:55

isGrounder que está todo el rato como marcándose 01:30:57

porque cada fotograma está detectando 01:30:59

que está 01:31:01

posado, cuando yo le doy 01:31:02

al salto 01:31:05

¿vale? se quita hasta que vuelve a detectar 01:31:05

Y ese, digamos, parámetro del animator, yo lo tengo por aquí, que es, que, a ver, tengo una booleana que pondrá isGrounded en el valor que tenga este isGrounded, que es un sí o un falso o un verdadero, ¿vale? 01:31:09

Vale. 01:31:28

Me vas siguiendo, no, digo, sé que ahora estoy como yendo de un lado a otro, pero bueno, ¿sí? 01:31:28

Sí, sí, en principio sí. 01:31:34

Vale, pues eso 01:31:36

Por ejemplo aquí, como yo quería que saltara para el ejemplo 01:31:40

Que era opcional, esto lo pone en la tarea que es opcional 01:31:43

Porque complica precisamente esto 01:31:46

Yo estoy usando el move, que sí que permite que en algún momento 01:31:48

Podamos saltar, porque ya te digo 01:31:51

Con el simple move no está pensado para eso 01:31:54

Eso lo que significa es que 01:31:59

Como por defecto hemos visto que el move 01:32:01

no mete gravedad al personaje 01:32:04

hay que meter las líneas 01:32:06

que he puesto antes de que hay que 01:32:08

meterle gravedad en todo momento, hay que hacer una variable 01:32:10

de gravedad, con este 01:32:12

menos 9,8 que es la fuerza de la gravedad 01:32:14

real, en física, vale, y en todo 01:32:16

momento se está sumando 01:32:18

a una especie 01:32:19

de fuerza que luego aplicaremos 01:32:22

en el move, vale, aquí estamos sumándolo 01:32:24

en todo momento a un vector que es el que luego 01:32:26

se usa para el vector move, vale 01:32:28

que en todo momento está empujando 01:32:29

digamos hacia abajo 01:32:32

el fall direction, el eje Y 01:32:32

en todo momento está sumando la gravedad 01:32:35

para que vaya hacia abajo 01:32:37

y en todo momento está cayendo hacia abajo 01:32:38

si hay un suelo lo detendrá 01:32:40

y si no, pues está cayendo hacia abajo 01:32:42

eso sí, si yo en algún momento 01:32:44

le doy a saltar 01:32:47

le doy a la barra espaciadora 01:32:49

en mi caso y ejecuto 01:32:51

el método de saltar y está posado 01:32:52

pues lo que va a hacer es 01:32:55

aparte de que va a hacer la animación de salto 01:32:57

que es esta que tengo yo aquí 01:32:59

esta de jumping, ¿vale? 01:33:01

Que la condición es 01:33:03

pues que primero esté posado 01:33:05

y aparte se ejecute el trigger 01:33:09

de jump, ¿vale? Pues aparte 01:33:11

al fold dirección le digo, no, 01:33:13

ahora no vas a ir sumando como en todo 01:33:14

momento 01:33:16

la fuerza de la gravedad, que es hacia abajo, 01:33:17

¿vale? Que de hecho si os fijáis está sumándola 01:33:21

porque la fuerza de la gravedad, 01:33:23

y en la física también lo es, es negativa, ¿vale? 01:33:24

Por eso estamos cayendo hacia abajo. 01:33:26

No estamos yendo en el eje I positivo. 01:33:28

Entonces detenemos en ese momento y a la fuerza de caer hacia abajo todo el rato 01:33:30

Lo que le decimos es, no, no, en este momento I lo que tiene que hacer es ir hacia arriba 01:33:37

Y hay otra variable que es el jump speed, que es este 8 01:33:41

Que es lo que hace que en ese momento concreto, el move, cuando se va actualizando 01:33:44

Pues el vector move este que tenemos que va sumando la dirección hacia adelante, derecha 01:33:50

De los distintos inputs que estamos metiendo, del eje vertical, lo que hemos hecho antes para mover al personaje, pues que le añada esa fuerza hacia arriba, momentánea, porque según pase este salto, que solo se ejecuta una vez, solo se ejecuta cuando pulsamos una vez, por esto este down, la barra espaciadora, 01:33:54

pues le añade esta fuerza, sube y luego inmediatamente otra vez empieza a calcular cómo ir hacia abajo y aplicarle la gravedad, ¿vale? 01:34:15

Vale, o sea, tú en todas las acciones que hace el avatar tienes que hacer un script de esas variables que tiene cada acción, ¿no? 01:34:25

Sí. 01:34:40

Más o menos, ¿no? 01:34:41

Claro, cuando empezamos... 01:34:43

Así que si tú le das a saltar, yo pensaría que solo le doy a saltar y ya está, pero nunca pensaría que si le vuelvo a dar a saltar, porque es ilógico que tú, si le das a saltar, estés todo el rato dando a saltar hasta que el muñeco no baja. 01:34:44

Claro, eso te lo da la experiencia de ir pensando. 01:35:00

es que eso hombre en la práctica anterior 5 ya ya se hacía esto es por eso digo que si ya se ha 01:35:04

hecho la 5 el personaje el robot sólo podía saltar una vez porque había un collider que estaba todo 01:35:11

el rato también en vez de con el carácter controller es un paso más allá porque es un 01:35:16

tema posterior que cuando tocaba el suelo ese collider o con un rey cast también se podía 01:35:20

hacer vale venía ha aplicado hay una booleana que diga está posado o no está posado para lo 01:35:25

Si no está posado, aunque le des a saltar, no puede saltar porque no puede hacer más saltos. 01:35:32

Incluso se puede decir que cuando se da dos veces al saltar, sea cuando se quita ese posado. 01:35:37

Y puedes dar la opción de que entonces haya un power up que te da el poder de hacer doble salto. 01:35:42

Pero no saltos infinitos, porque entonces el juego te lo pasa porque va volando. 01:35:47

Pero sí, eso ya estaba. 01:35:52

Entonces, tú cuando empiezas un script, aquí hay que ir declarando todas las variables que van necesitando. 01:35:53

Pero tú en cualquier momento dices, ah, necesito uno de esta posado. Pues vuelves aquí, lo creas y aquí, por ejemplo, pues en algún momento habrá uno de esta posado o se creó... Bueno, no, no está el de esta posado, a diferencia de la unidad 5, que sí que había que hacer una booleana de esta posado, ¿vale? 01:35:59

porque aquí no es necesario gracias al 01:36:19

gracias al carácter 01:36:22

controller, aquí el carácter controller 01:36:23

si te fijas la condición de que esté posado o no 01:36:25

te la da él mismo cuando 01:36:27

te permite hacer esto 01:36:29

que esto devuelve 01:36:31

directamente verdadero o falso 01:36:33

porque lo detecta directamente con respecto 01:36:35

a la 01:36:37

aquí ya me está atacando todo Dios 01:36:38

con respecto a la 01:36:41

a la cápsula que tiene 01:36:43

el personaje en su carácter controller 01:36:45

y ojo lo mismo 01:36:47

la gravedad se da hasta donde 01:36:49

se encuentre esa cápsula 01:36:51

si yo por ejemplo le digo 01:36:53

como ponía por defecto 01:36:54

voy a subir al personaje 01:36:56

ves que la cápsula ahora llega hasta el suelo 01:36:58

y sobrepasa los pies 01:37:01

lo importante para detectar esa colisión 01:37:02

y por eso ahora está suspendida en el aire 01:37:05

es ajustar bien la cápsula 01:37:07

¿vale? 01:37:08

ves que ahora se posa en donde 01:37:11

pues en donde esté 01:37:13

ahora yo salto al personaje y salta 01:37:14

y todo lo hace en función a 01:37:17

igual que hacíamos con los colliders 01:37:19

y el rigidbody, pero bueno, es otra forma 01:37:21

de hacerlo, muy parecida, pero 01:37:23

que bebe de esa cápsula que te da 01:37:25

el collider. Y luego 01:37:27

los colliders normalmente 01:37:29

tienen los 01:37:31

métodos de onTrigger y 01:37:33

onCollision, ¿no? Que esto 01:37:35

se veía en 01:37:37

el tema 3, por ejemplo, y también en la 01:37:39

tarea 5. Aquí, como no 01:37:41

hay collider, ¿vale? Porque 01:37:43

ahora mismo este objeto 01:37:45

tiene algo como un collider pero no tiene el componente 01:37:46

collider, entonces no puedes 01:37:49

recurrir a esos onCollision 01:37:51

o onTrigger, tiene su propio método 01:37:53

que también lo pone en los apuntes 01:37:55

¿vale? que es 01:37:57

lo pone aquí 01:37:59

este onControllerColliderHit 01:38:01

que es un poco lo mismo 01:38:03

cuando es 01:38:04

en vez de void 01:38:07

onTrigger, enter, etc. es 01:38:08

cuando algo toque al collider 01:38:11

cuando otro collider toque 01:38:13

la cápsula esta del character controller 01:38:15

pues ya se pueden 01:38:18

ejecutar acciones 01:38:19

¿vale? 01:38:21

es como una especie de forma más avanzada 01:38:23

que permite otras cosas 01:38:26

pero que bebe un poco de lo que ya 01:38:27

hemos ido viendo en anteriores temas 01:38:29

¿vale? 01:38:31

y bueno aquí por ejemplo 01:38:35

habla de lo del root motion 01:38:37

esto que hemos dicho de la propia animación 01:38:38

etcétera ¿vale? 01:38:40

no sé, más dudas o más cosas 01:38:42

que queráis que veamos 01:38:44

hoy que tengo 01:38:46

dos alumnos 01:38:48

que otros días estaba yo solo 01:38:49

en las tutorías 01:38:52

luego está todo lo del NPC 01:38:54

pero es verdad que es más complicado 01:38:58

si queréis lo vemos 01:39:00

eso es lo de la inteligencia artificial 01:39:01

que es un apartado digamos opcional en la tarea 01:39:03

eso es el zombie, entiendo 01:39:06

eso es el zombie, ¿no? 01:39:07

si queréis lo vemos un poco por encima 01:39:09

en la 01:39:13

en la tarea viene explicado también 01:39:14

en cómo conseguirlo. Es verdad que a veces hay que interpretarlo y se tarda, pero a ver, espera, 01:39:16

que alguien me ha escrito algo. Ah, vale, que la compañera está, pero no puede participar. Vale, 01:39:21

vale. Vale, fenomenal. Sí, mira, para que veáis un poco el funcionamiento del zombie, por si 01:39:27

queréis probar. Yo ahora mismo, y me voy a la ventana, bueno, espera, primero voy a ajustar 01:39:34

viene este el collider vamos el collider el carácter controller para que esté 01:39:41

como debiera 01:39:46

yo no sé qué desecho pero yo creo que ya está como estaba al principio 01:39:51

vale ahí lo tengo y ya estaba posando el suelo vale entonces si nos fijamos yo 01:39:55

tengo varios zombies zombies o lo que queráis que están deambulando solos eso 01:40:01

no los controla nadie son inteligencias artificiales que además van andando y de 01:40:06

vez en cuando se paran y de pronto dice nada pues voy a otro lado y se pueden a patrullar y yo cuando 01:40:11

voy andando también y me acerco según ciertas condiciones me pueden ver y cuando me ven por 01:40:17

ejemplo este me va a ver enseguida ya cuando me pongo delante ves que ahora de pronto me está 01:40:23

siguiendo bueno se le va un poco la pinza pero cuando van me van siguiendo en todo momento hasta 01:40:28

que me ven y me empiezan a agredir vale ahí hay otro que está parado y no hace nada hasta que me 01:40:33

vea vale por lo mismo ahora me va a ver y ahora se puede correr y me intenta dar vale yo puedo 01:40:40

ir escapando y de hecho está configurado para que cuando me alejo 10 metros o más bueno aquí 01:40:48

no me va a dejar estoy intentando hacer le he puesto que pueda subir muchas pendientes y los 01:40:53

zombies no vale cuando llevo ya un tiempo cuando estoy a una distancia como que me han dejado de 01:40:58

ver, que yo he configurado, pues 01:41:04

a ver, zombie 01:41:06

voy aquí, pues ya de pronto como que 01:41:07

se han olvidado de mí y vuelven a hacer el patrullaje 01:41:10

que es otro estado, ¿vale? 01:41:12

Esta es la lógica que tiene en este 01:41:14

juego. Vamos a ver un poco cómo es 01:41:16

¿te parece? Sí. Esto ya te 01:41:18

digo que es más avanzado 01:41:20

y me interesa con que veáis 01:41:21

el vídeo que hay en el tema 01:41:23

el que está en la parte que hay que ver 01:41:25

la azul, ¿no? Lo saber más 01:41:28

como siempre, no son para el examen 01:41:29

Pero bueno, siempre tienen más información 01:41:32

Pero estos son, digamos, tres prefabs 01:41:34

De un... 01:41:36

Del zombie, ¿vale? Me voy a centrar en uno de ellos 01:41:38

Solo, voy a dejar uno 01:41:40

Pues los tres son iguales, en realidad 01:41:41

Yo he cogido otro 01:41:43

Personaje por ahí, de internet 01:41:45

Que de hecho creo que lo dejaba 01:41:47

Se puede... Se puede bajar 01:41:49

¿Vale? Y tiene su propio controller 01:41:51

Y este zombie 01:41:53

Y esto es una forma un poco distinta 01:41:55

De hacer el... 01:41:57

Una máquina de estados de animación, ¿vale? 01:41:59

Un animator controller que este en vez de basarse en, como no vamos a nosotros meter inputs de pues doy a una tecla o le doy a tal otra tecla, sino que va a ir haciéndolo autónomamente, tiene lo que en los apuntes se llaman estados, ¿vale? Porque es lo que se llama una máquina finita de estados, ¿vale? Una FSM. 01:42:01

entonces cada una de las acciones vale yo me pongo aquí selección me voy a desactivar estos 01:42:21

dos para que no moleste me centro en este vale yo cuando me meto en una animación vale no se 01:42:28

ve el personaje pero tengo el personaje parado el personaje caminando vale con los brazos 01:42:32

extendidos el ataque cuando me cuando está cerca de mí y otro que es que corre y vas a ver que lo 01:42:39

que he hecho es generar una variable de tipo int un parámetro del animator vale y para pasar de 01:42:47

uno a otro las condiciones son siempre que ese ese número puede ser entre el 0 y el 3 vale y yo 01:42:52

he ido como configurando este este zombi puede hacer cuatro cosas la primera es el 0 pero 0 1 01:43:00

2 3 4 cosas una estar quieto otra andar otra cuando me detecta correr hacia mí y otra atacar entonces 01:43:06

Entonces esto es lo de siempre, pues cuando empiezas a ver un poco cómo hacerlo, al empezar el juego he dicho, mira, va a haber cinco estados que voy a guardar en una variable llamada state. 01:43:13

El cero, pues lo que te he ido diciendo. Y lo que iremos detectando es, según se vayan cumpliendo condiciones, que se pase de uno a otro. 01:43:28

Si el estado es el 1 porque ya están dando y la distancia con el objetivo, que sería el personaje, es menor a 1,5, paso al estado 0. Si he llegado cerca de mi destino es cerca de... Y aparte se han generado cuatro ubicaciones en el mapa, aleatorias o las hemos puesto, que se han guardado en un array de posiciones. 01:43:35

Entonces, ¿qué es lo que va pasando? Que vamos a ir actualizando en ese array de posiciones que hay aquí, de cuatro posiciones que se han puesto en el espacio, y según arranca el juego hay un método que se llama, cuando pasan cuatro segundos de juego, en el invoke, un método que se ha creado que se llama Ronda Random. 01:44:01

Y si no se ha detectado al personaje, si hay una booleana que lo que hace es que se detecta al personaje o no 01:44:24

Que es cuando activa el estado 2, que es el que se pone a perseguir al personaje 01:44:33

Si no se ha detectado al personaje, pues habrá un momento que se pase al estado 1 01:44:37

Que por un lado animará en todo momento la animación de ese personaje 01:44:42

Me refiero a que en este caso extienda los brazos y camine 01:44:48

Pero aparte se le asigna un destino, ¿vale? Hacia el que tiene que ir. Va a coger de esos cuatro elementos de la RAI uno aleatorio que tenemos aquí y va a ser el destino hacia el que va a ir en todo momento. 01:44:51

¿Vale? Entonces, nuevamente, importante, para hacer todo lo relacionado, esto lo explica en el tema, con la inteligencia artificial hay que cargar una librería nueva, ¿vale? 01:45:05

Porque si no, por ejemplo, no se puede acceder a este NASMESH agent, que es el que sirve para acceder a las variables del NASMESH, que es el que define, igual que el character controller, cómo movemos un personaje con el character controller 01:45:19

En este caso es el que define cómo se mueve un agente, un GameObject de inteligencia artificial, que se moverá, esto también lo explica en el vídeo, en las mallas que se configuren como caminables. 01:45:32

¿Ves que hay partes del suelo que están con esta azul? Estas son las zonas por las que el personaje de inteligencia artificial, con el Namesh Agent que te he indicado antes, se va a poder mover. Por eso, por mucho que yo suba aquí arriba, el personaje, si no tiene forma de acceder por estos caminos, no va a poder caminar por ahí. 01:45:51

Entonces, con el setDestination, con este método que tenemos aquí, 01:46:15

lo que podemos ir es diciéndole sitios a los que tiene que ir el personaje. 01:46:20

En este caso, el zombie, que es el que tiene este script. 01:46:24

Y aquí vamos poniendo posiciones. 01:46:27

Y entonces el personaje va a ir hacia esa posición. 01:46:29

Y podemos ir cambiando las posiciones para que cuando llega una, 01:46:32

luego vaya otra. 01:46:36

¿Vale? Y por eso hay cuatro puntos que aleatoriamente se van a ir diciendo que sean el destino. ¿Vale? Luego, ¿cómo me detecta el personaje? Esto está en el propio enunciado del tema, lo cuenta, esto que hay aquí. 01:46:36

Pero básicamente es que hay un valor, un método que se llama distance que permite calcular distancias entre objetos. Entonces aquí tenemos por un lado la posición donde está el personaje que tiene este script que es el zombie y la posición del superviviente que en todo momento, la posición del superviviente se está calculando en todo momento con este transform que tenemos aquí, ¿vale? 01:46:58

que dice, busca 01:47:26

¿vale? 01:47:28

esto no sé si 01:47:30

os suena esto más avanzado, pero 01:47:31

igual que se pueden coger los componentes 01:47:34

de esto más o menos empecé a hablar un día 01:47:36

pero igual que se pueden coger los componentes 01:47:38

que están en el mismo objeto que tiene este script 01:47:40

¿vale? esto es lo que ya hemos hablado 01:47:42

en varias ocasiones 01:47:44

si hablamos de la 01:47:45

clase GameObject, ponemos un punto, hay diferentes 01:47:48

tipos de find, que lo que 01:47:51

hacen es, se puede por nombre 01:47:52

de objeto por encontrar 01:47:54

GameObjects que tienen un tag 01:47:56

los tags, recordad que son 01:47:57

estos tags 01:48:00

que tenemos aquí 01:48:02

y aquí le estamos diciendo, veis que el personaje 01:48:03

del superviviente tiene el tag player 01:48:06

o podemos crear otro nuevo, dice 01:48:08

busca, encuentra un objeto 01:48:10

en la escena que tenga este tag 01:48:12

y coge su transform y me lo guardas 01:48:14

en este 01:48:16

SubAerobotPost que es una variable 01:48:18

de tipo transform 01:48:20

es decir, guarda la información de un componente 01:48:22

transform entre otros las posiciones las rotaciones y la escala entonces eso en 01:48:24

todo momento ese survivor post va a estar cogiendo la posición del personaje 01:48:29

es verdad que aquí lo hace en el start coge esta survivor post y en algún 01:48:37

momento tiene que estar actualizando lo que es que si se detecta vale coge eso 01:48:43

Como hemos guardado el transform de ese SurvivorPost, en todo momento puede estar buscando dónde está la posición. 01:48:53

Una variable que hemos creado aquí va cogiendo en todo momento, porque este detectSurvivor, si os fijáis, es un método que se ejecuta cada fotograma. 01:49:06

Está en el update. Y cada fotograma va a estar calculando la distancia entre el propio zombie que tiene el script y el personaje. 01:49:15

Y por otro lado está cogiendo la dirección en la que está ese personaje. Esto también lo ponía en la práctica 5 para cuando se hacían las torretas que disparaban, para que vaya calculando en todo momento hacia dónde tiene que ir mirando la torreta, que es la posición del personaje. 01:49:22

Pero hay una forma de siempre saber hacia qué dirección tiene que ir apuntando un objeto, que es que si al objeto que tiene que encontrar le restamos la posición de sí mismo, te da el ángulo hacia el que mira, ¿vale? 01:49:44

No sé, esto lo venía explicado también en otro punto, pero si yo, por ejemplo, a ver, voy a poner un segundo, eje de coordenadas vacía. 01:49:59

Vale, un vector 2, por ejemplo, un vector 3, sería esto en tres ejes, pero voy a hacer que se vea un poquito mejor. 01:50:15

si yo tengo un personaje 01:50:22

que está en este punto 01:50:25

y vamos a decir que aquí 01:50:26

está el zombie 01:50:29

y aquí está el personaje 01:50:31

lo que estamos buscando 01:50:32

aquí es, para detectar al 01:50:35

personaje, tener tanto la distancia 01:50:37

por si se acerca mucho, ahora vemos 01:50:39

como el ángulo de visión 01:50:41

del zombie, para que si nos acercamos 01:50:43

por la espalda, tarde más en detectarnos 01:50:45

y al contrario, si estamos 01:50:47

justo delante de él, aunque estemos más lejos 01:50:49

Nos detecte. Entonces, imaginaos que tenemos, a ver, vuelvo aquí, tenemos este eje, ¿vale? Que es el espacio. Si yo le digo que me calcule la dirección del vector que hay entre este personaje y este, 01:50:51

lo que hay que coger es la posición de uno y restándole el otro, lo que nos da es la dirección que tiene, ¿vale? 01:51:11

¿Sí? Entonces, si hacemos esa operación con este vector hacia el personaje, que es un vector 3 que hemos creado nosotros, 01:51:18

es otra variable que hemos declarado aquí, lo que podemos es en todo momento ir viendo la dirección hacia la que está el personaje, ¿vale? 01:51:26

Por ejemplo, si yo pongo aquí un debug log para ir comprobando en todo momento qué vale el vector to player, que esta es la comprobación que siempre hay que ir viendo para ir comprobando que las cosas funcionan, ángulo zombie personaje. 01:51:34

más que un ángulo lo que nos va a dar 01:51:52

es un vector de 3 01:51:54

con eso 01:51:56

la dirección hacia la que mira un personaje 01:51:58

que esto se puede interpretar como un ángulo 01:52:00

realmente, los vectores 01:52:02

aparte de ser posiciones en el espacio 01:52:04

como el vector 3 que tenemos 01:52:06

aquí en posición 01:52:09

cuando por ejemplo le pasamos un vector 3 01:52:10

a un add force o a un 01:52:12

translate, lo que estamos diciéndole es 01:52:14

hacia qué dirección tiene que ir 01:52:17

añadiendo algo, entonces también sirve 01:52:19

para dar direcciones si ahora comprobamos el ángulo de mi personaje vamos a ir viendo 01:52:20

a ver porque tengo más cosas aquí vale no perdona porque detectaron de barlos 01:52:29

primero tengo que guardar importante y voy a darle a play vale y vais viendo que el ángulo 01:52:37

del personaje va variando según vamos moviendo de un lado a otro que voy a la izquierda en x se va 01:52:47

haciendo más pequeño y si voy hacia la derecha vale el ángulo con respecto al personaje veis 01:52:55

que va aumentando vale esto bueno en eje en eje z básicamente lo que estará calculando será un poco 01:53:00

la dirección y en y como siempre estamos en el mismo eje pues realmente no cambia la dirección 01:53:09

pero en eje Z básicamente lo que está calculando es un poco la distancia, un poco lo que hemos hecho aquí también, pero solo en uno de los ejes. 01:53:14

Si este vector, usamos este método de vector 3, que es el de ángulo, lo que podemos hacer es calcular en todo momento cuánto ángulo hay entre donde mira, en este caso el zombie, 01:53:22

el personaje zombie hacia adelante, donde tiene su mirada, con respecto al ángulo que hay de, es decir, la posición que tiene el que hemos calculado aquí antes, ¿vale? 01:53:36

Entonces, básicamente con esto, en esta variable de ángulo del cono, lo que estamos calculando es el ángulo que hay hacia donde mira el personaje y la diferencia que hay con este valor que hemos encontrado aquí. 01:53:49

No, eso que 01:54:04

tú lo que estás pretendiendo 01:54:06

es saber hacia dónde mira 01:54:09

el zombi para ver si te localiza 01:54:11

Siempre dentro de ese 01:54:13

ángulo de visión 01:54:15

Con esto, digamos 01:54:17

Sí, eso es lo que estamos buscando 01:54:19

Exacto 01:54:21

Todo el rato, ¿dónde estás tú? 01:54:22

Y a su vez 01:54:26

se mueve de posición 01:54:27

en posición cuando llega 01:54:29

una se traslada a la otra 01:54:31

con el otro script 01:54:33

eso es, con esto lo que estamos buscando 01:54:34

es digamos 01:54:37

el ángulo que hay, la dirección que hay 01:54:38

entre zombie y personaje 01:54:41

y aquí lo que estamos 01:54:43

haciendo es traducir 01:54:45

en grados, el ángulo en grados 01:54:47

de 0 a 180 que hay 01:54:50

entre donde está mirando el personaje 01:54:51

y la diferencia 01:54:53

es decir, si yo tengo 01:54:55

el personaje mirando para adelante 01:54:57

y el personaje está en su espalda 01:54:59

tiene un ángulo de 180. Esto devolvería 01:55:01

180. ¿Vale? Si yo estoy 01:55:04

a la derecha del personaje, este está mirando 01:55:06

para adelante, 01:55:08

esto está dando un valor que, al estar 01:55:10

a la derecha, pues sería de 90 01:55:12

grados. Guardaría un 90. 01:55:14

¿Por qué? Porque ahora lo que vamos a hacer es 01:55:16

conjugar... 01:55:18

Claro, que si la distancia 01:55:20

del personaje que hemos calculado aquí 01:55:22

es menor a una distancia que yo he definido 01:55:23

que sea, es una variable 01:55:26

que tengo aquí, de 20 metros. 01:55:28

Esto es lo que yo decida. 01:55:30

si el personaje está a 20 metros o menos, es decir, está más cerca de 20 metros del personaje, 01:55:31

y además el ángulo en el que me encuentro con respecto a la visión del zombi es menor a la que yo también he puesto aquí, 01:55:38

que es una que he declarado como 20, tiene 20 grados, digamos, de los 360 hacia la izquierda y hacia la derecha, 01:55:44

es decir, abarca una visión de 40 grados, que si esta distancia, esta referencia que hay entre donde mira el zombi 01:55:54

y donde está el personaje, que dan grados, es menor a los 20 grados de diferencia, entonces detecta al personaje. 01:56:03

Es decir, que si estoy en un campo de visión frente al zombi de 40 grados y además estoy a menos de 20 metros, 01:56:11

De pronto hay una booleana, que es la que va a ir dando condiciones aquí para ir yendo a un estado u otro, que irá delimitando qué hace el zombie, los comportamientos. Y esa booleana empieza por falsa, porque no nos ha detectado, pero cuando nos detecta, esa booleana pasa a ser verdadera. 01:56:19

Luego aparte, otra condición 01:56:37

Si esto no se cumple en todo momento 01:56:39

Mira a ver si la distancia del jugador 01:56:41

Independientemente del ángulo 01:56:43

Aquí ya da igual que estamos en su espalda 01:56:45

Si yo me acerco al zombie menos de 2 metros 01:56:47

También me detecta, me nota 01:56:49

Aunque no esté en el ángulo 01:56:51

¿Vale? Es decir 01:56:53

Esta condición es más restrictiva que esta 01:56:54

Porque esta se cumpliría siempre 01:56:57

En función de la distancia 01:56:59

Porque siempre 01:57:02

Entre 20 y 2 01:57:03

Pues siempre nos va a detectar 01:57:05

pero nos cargamos un poco la variable que es la condición del ángulo, ¿vale? 01:57:06

Y luego, si no se cumple nada de esto, pues significa que no me está detectando, 01:57:12

por tanto, sigue o estando en falso, ¿sí? 01:57:15

Y eso es lo que luego va haciendo que vayamos pasando de un estado a otro. 01:57:18

Esto es lo que hay que ir configurando. 01:57:22

Así que, bueno, esto es un poco cómo funciona luego eso. 01:57:27

Hay un método propio, ¿vale? 01:57:30

Igual del NATMES, que es este, bueno, primero accedemos al NATMES, que se refiere básicamente a este componente de NATMES agent, ¿vale? De ahí se cogen, NATMES agent, relación con NATMES agent. 01:57:32

Entonces yo guardo la información en agent, ¿vale? Y en todo momento con el set destination yo lo que voy haciendo es, este personaje que tiene este NATMES tiene que irse moviendo hacia donde yo le diga aquí en todo momento, que se puede ir actualizando, claro. 01:57:50

en todo momento va a ir calculando una meta 01:58:02

que puede ser, por ejemplo 01:58:05

la posición en cierto momento 01:58:08

va a ir cambiando 01:58:09

si detecta el personaje, cogerá 01:58:11

la posición del personaje y lo irá siguiendo 01:58:13

fotograma a fotograma, lo irá refrescando 01:58:15

y si no lo ha detectado 01:58:18

si no lo ha detectado, que es lo que pone aquí 01:58:19

ese destino 01:58:22

al que se tiene que ir moviendo el personaje es 01:58:23

uno de los puntos, las posiciones 01:58:25

de uno de los puntos que tengo aquí 01:58:28

esparcidos por el espacio 01:58:29

pues para que vaya de un punto a otro 01:58:31

¿vale? se podría hacer aleatorio pero aquí se han puesto 01:58:33

cuatro GameObjects vacíos 01:58:35

cuatro Empties y este 01:58:37

Zombie pues irá haciendo la ruta entre estos cuatro 01:58:39

¿vale? 01:58:41

que esos cuatro puntos son los que están 01:58:43

metidos en este 01:58:45

Array, entonces 01:58:47

que llega a un 01:58:49

a ver 01:58:51

que llega 01:58:52

lo tenemos aquí 01:58:54

bueno, es que he borrado 01:58:59

esto, ¿vale? que 01:59:01

en todo momento 01:59:02

el agent está yendo hacia el objetivo 01:59:05

lo que va a ir cambiando es que objetivo es ese 01:59:07

si por ejemplo 01:59:09

estamos en el modo 0 o 1 01:59:11

de los estados de que no me ha detectado 01:59:13

en el estado 1 ya irá andando 01:59:15

y pues 01:59:18

aleatoriamente cada cierto tiempo 01:59:19

va a ir 01:59:21

chequeando pues oye 01:59:22

ahora voy a sacar un número aleatorio 01:59:25

entre el 0 y la longitud 01:59:27

del array que el máximo es 3 01:59:29

y cógeme uno de esos tres 01:59:31

valores, ¿vale? y me lo guarda ese nene 01:59:34

y luego lo que va a dar es la posición 01:59:36

de el elemento de narray 01:59:38

que haya salido aleatoriamente antes 01:59:39

y el objetivo hacia el que tiene que ir es esa posición 01:59:41

entonces cada cierto tiempo se va a ir 01:59:43

reseteando para que el personaje 01:59:46

vaya a esa posición 01:59:48

el zombie, por eso cuando 01:59:49

empieza el juego, que empieza parado 01:59:52

porque digamos que este 01:59:54

cálculo de la ronda 01:59:56

se invoca para que empiece a los 4 segundos 01:59:57

y se vaya ejecutando cada cierto tiempo 01:59:59

Si el estado es 1, cada 20 segundos vuelve a ejecutar ese método de ronda random 02:00:01

Que es la que define nuevos estados de nuevas metas de las que hay aquí preconfiguradas 02:00:08

Entonces cuando llega una, cuando detecta que se ha alcanzado, se para ahí y a los 4 segundos dice 02:00:16

A ver a cuál voy aleatoriamente y va a esa 02:00:22

¿vale? 02:00:26

y el personaje se está moviendo por el 02:00:28

NADMES, no tiene ni RigidBody 02:00:30

ni nada más, se está 02:00:32

moviendo porque hay un setDestination 02:00:34

y se va moviendo a la velocidad que tenga 02:00:35

el NADMES aquí puesto 02:00:38

¿vale? 02:00:39

estas cosas 02:00:49

más o menos están 02:00:50

sugeridas o incluso hay 02:00:51

fragmentos de código iguales, por ejemplo esto del 02:00:53

ángulo de visión, etcétera, está 02:00:56

tal cual, si no me equivoco 02:00:58

en los enunciados 02:00:59

de la tarea 02:01:02

y nada, pues es ir 02:01:03

resolviendo 02:01:05

pues como se van 02:01:07

los problemas que van 02:01:10

surgiendo, como irlo resolviendo y hay que darle muchas 02:01:12

vueltas, eso seguro 02:01:14

por eso lo de inteligencia artificial lo he dejado un poco 02:01:15

en segundo plano porque sí que 02:01:18

tiene más vueltas, pero lo de mover el 02:01:19

personaje y el carácter controller y eso 02:01:22

sí que creo que es más 02:01:24

asequible y más con lo que hemos visto hoy 02:01:26

Tutoria 11 - DEIM - UT 6 - Curso 23·24 - 25 Abril - Contenido educativo

Del mismo autor…

Día del abrazo

CONVERSACIONES: Día de la PAz

Día del abrazo, 2026

Defensa proyecto Ignacio Cabezas

VIDEO APIAC03.- AjustesContables

4.012026-ProyectoAD-AA

PROBLEMA RESUELTO MRU