Vídeos UT3 - #1 - DEIM - Curso 25·26 | Mediateca de EducaMadrid

Hoy vamos a empezar a hablar, o vamos a enfocar más, en lo relativo al motor de físicas y, bueno, pues ya importar alguna geometría, digamos, con más detalles relacionados, por ejemplo, con los colliders, para que haya colisiones y se encuentren los objetos entre sí a nivel físico, etcétera, ¿vale? 00:00:01

Bueno, como pone en el propio enunciado 00:00:22

Que lo tengo por aquí 00:00:25

Ahí está 00:00:26

Hay que conseguir el objetivo 00:00:27

Y a veces los juegos son un poco simples 00:00:29

Pero de lo que se trata es de poneros en tesituras 00:00:31

Que no son las más obvias 00:00:33

Pero que si sabéis implementar en un juego simple 00:00:37

Sabéis extrapolarlo a otros 00:00:40

¿Vale? Bueno, consiste en que con físicas 00:00:42

Movamos una pelota 00:00:45

Que se va a ir metiendo en estos agujeros objetivos 00:00:46

y que si la pelota se cae de esta, dependiendo del nivel, será de una forma u otra, si se va cayendo la bola de la plataforma, 00:00:50

pues se pierde y se reinicia el nivel. Cada vez que llegamos a uno de estos objetivos, se pasa a otro nivel, a un nivel siguiente. 00:00:58

Esto ya implica, y lo veis aquí, que tiene que haber diferentes escenas que corresponden con cada uno de los niveles. 00:01:06

En la unidad 4 se habla más sobre las escenas o la gestión entre escenas y en el enunciado ya de este tema se esboza un poco cómo hacerlo. 00:01:13

Por tanto, no es mala idea que en cierto momento también empecéis a leer la unidad 4 antes de entregar esta. 00:01:23

Pero yo creo que se explica más o menos adecuadamente, o sea, la introducción necesaria para hablar de estos cambios de tareas en esta sección de aquí 00:01:32

que habla del Scene Management y de los Build Settings, ¿vale? 00:01:40

Lo mismo, leeros los enunciados, siempre del tirón, 00:01:43

hacéis una primera lectura para, aunque os suene un poco extraño a veces, 00:01:47

lo que se está hablando, tener una idea general, 00:01:52

y luego ya se va desglosando y avanzando poco a poco. 00:01:54

¿Vale? Entonces el juego consiste en eso. 00:01:58

Para la tarea se os aportaban unos FBX, 00:02:00

entiendo que ya en módulos como en el de animación o en el de modelado, 00:02:04

O incluso en el de color. Habréis visto formatos de exportación y uno de ellos es el FBX. Pero básicamente los FBX son paquetes de distintos componentes. Es decir, pueden incluir luces, pueden incluir mallas, pueden incluir los materiales. 00:02:10

No es como el OBJ, que está destinado solo a guardar una geometría. 00:02:30

Sin más, aquí vais a ver que cuando arrastráis esos FBX, se van a ver así, con este triangulito que permite desplegar qué contiene ese FBX. 00:02:35

Y veis que hay diversas cosas, y en algunos ahí puede haber más que en otras. 00:02:48

Eso dependerá de cómo se haya creado y se haya guardado ese FBX. 00:02:52

esto significa que cuando arrastramos 00:02:55

lo normal es, tengo una geometría 00:02:58

y la arrastro a nuestra jerarquía 00:03:00

¿vale? vais a ver 00:03:02

una cosa que al principio 00:03:04

molesto, pero que es que dices, ah, tengo varios 00:03:06

bueno, vais a ver que aquí tengo 00:03:08

el collider como game object 00:03:10

¿vale? y luego hay otra malla que es este 00:03:12

terreno 1 collider, veis que 00:03:14

está el propio game object, que es el que agrupa 00:03:16

SFBX, más luego 00:03:18

si clicamos, la propia malla 00:03:20

que tiene dentro SFBX 00:03:22

que puede ir de manera independiente. Y cuando tenéis una geometría de este tipo, como es de X, tiene este simbolito de cajita, que no es exactamente igual que el de los prefabs, 00:03:25

que era completamente azul, sino que tiene este precintillo. Y el problema está en que por defecto no se pueden separar los elementos. 00:03:37

Yo quiero poner solo un material y no me deja aplicarlo en ocasiones. Pero hay una forma de, una vez arrastrado a la jerarquía, desempaquetar para usar independientemente los distintos elementos de un FBX. 00:03:45

En este caso, si fueran otros contenedores de geometría 3D como hay, que también admiten más elementos, sería similar. Pero con clic derecho en una de estas cajitas, si vamos a prefab, porque en realidad es un prefab, aunque esté compuesto de una malla, está la opción de desempaquetar. 00:04:00

Y la de desempaquetar completamente, que como dice su nombre, si os fijáis lo que hace es disgregar los elementos que tenga. Voy a borrar esto porque a lo mejor en ocasiones lo que queremos es solo eso, tener uno de los elementos. Hasta que no se desempaqueta en ocasiones, esto no se puede hacer. Aquí está apareciendo que sí, pero en ocasiones puede dar problemas. 00:04:19

Hay una forma, y esto adelanta algo que veremos en el tema 5 sobre animaciones, que es que si yo quiero tener uno de los elementos del interior de un FBX, por ejemplo, independientemente, completamente independiente, antes de llegar a la jerarquía, si seleccionáis a uno y lo duplicáis, que es con CTRL-D, al dar a CTRL-D, se hace ese duplicado y ya es independiente. 00:04:41

Entonces, bueno, pues lo tenéis. Para ciertos usos que ya iremos viendo y que podrían ser interesantes, desempaquetados tanto ya en la jerarquía o en el propio origen, desde el panel proyecto. 00:05:03

Una cosa importante cuando vais clicando en cada uno de estos elementos es que en el inspector, como siempre sucede realmente, os va enseñando las propiedades de cada elemento y os da pista de qué es cada cosa. 00:05:20

Igual que, por ejemplo, un material. Se ha introducido un poquito los materiales cuando también se habla de materiales físicos en este tema, aunque los materiales físicos habréis visto que van de otro modo, no son exactamente lo mismo, ¿vale? Podéis ir viendo qué tiene cada elemento. 00:05:31

Y hay una opción importante que en ocasiones puede parecer que no está en el inspector porque puede estar recogido como ahora, que es esta parte inferior donde podéis previsualizar, por ejemplo, los modelos 3D, ¿vale? Y es muy útil, si no, desplegad estas dos líneas para arriba y es que está encogido, ¿vale? Si arrastráis veréis representaciones de las geometrías. 00:05:47

Y esto es útil, por ejemplo, en esta tarea para ver por qué o qué diferencia hay aparentemente entre los dos terrenos 1, que son para el primer nivel, en el que digamos que la plataforma no se mueve en sí misma, sino que está fija, pero bueno, pues si la tenéis aquí, decir, si es lo mismo, aparentemente parece lo mismo. 00:06:07

Pero si os fijáis luego, por ejemplo, en la malla que tiene cada uno, hay una versión importante, y es por lo que está hecho a propósito en esta tarea. Contiene un agujero, ¿vale? Que en uno está simplificado y en otro tiene una geometría bastante más compleja. 00:06:28

¿Vale? Entonces, bueno, alguna diferencia habrá para que estén estos dos elementos por separado, ¿no? 00:06:44

Muy rápido voy a hacer un repaso a qué son las físicas en Unity, que son los componentes RigidBody y los Collider, ¿vale? 00:06:54

Y cuáles son sus funciones, porque es esencial conocerlo, ¿vale? 00:07:02

Pero cuando creamos una de estas primitivas, por ejemplo el cubo, por defecto vais a ver que tienen ya agregado, aparte de un mesh renderer que lo que hace es, y se asocia con este mesh que tenemos aquí, por ejemplo en este elemento, 00:07:06

Un mesh renderer que está mostrando la geometría y el mesh filter que está mostrando cuál es la geometría y cómo está texturizada o qué textura, qué material tiene la geometría. 00:07:22

También viene un tercer componente, dependiendo de la primitiva, será uno u otro, que es un collider de los distintos tipos que hay y que se ven en el tema. 00:07:38

En los contenidos los tenéis. Si, por ejemplo, creáramos una esfera, como sucederá con la bola, pues viene con su sphere collider. Y en principio, lo borro, ¿vale? Tengo aquí una esfera que lo único que he hecho, bueno, no es lo único, voy a eliminar. Así es como vendría por defecto. Bueno, no, voy a crear otra porque si no, esta avanza demasiadas cosas. 00:07:47

Cuando creo esta bola, y digo esto es una bola, creo la esfera, viene con ese Sphere Collider. 00:08:08

Y fijaos, cuando tenemos Colliders, que en general, hay una excepción, pero en general, imagino que lo veis bien, 00:08:16

viene, aparte de que se vea la representación de esa malla, se ve como un sólido, se ve esta mallita verde que representa lo que es el Collider. 00:08:24

De hecho, si activo y desactivo el collider, veis que se marca y se desmarca, ¿vale? Bueno, no llega a desaparecer, pero veréis que se atenúa un poco el color. De hecho, si quito por completo ese collider, pues desaparece, ¿vale? 00:08:34

Esto lo que significa o lo que persigue es delimitar, y son independientes, de hecho se puede mover aquí el center y veis que son independientes, es representar por un lado los límites de la geometría, que es lo que se ve mediante el mesh renderer, que es la parte visual, y luego está lo que es la parte de cómo tienen que colisionar y comportarse físicamente los objetos. 00:08:49

¿Sí? Es decir, por mucho que se vea aquí la bola, realmente no se va a sostener sobre este suelo porque la parte que es, digamos, sólida, la que percibe las colisiones, ahora mismo la tengo aquí ubicada, ¿vale? 00:09:13

Las dos se mueven en conjunto, pero veis que en uno de los parámetros del collider hay un cierto desfase que le he puesto, ¿vale? 00:09:31

Porque así no me puede interesar que sea más grande, que ocupe más la parte de la colisión más allá de lo que es la geometría en sí, ¿no? 00:09:38

Entonces, si yo, por ejemplo, ahora esta bola, y esto es algo importante, que además viene como dos veces o más como destacado en el tema, 00:09:46

Para que funcionen las colisiones en sí, tiene que haber un objeto que se mueva o que tenga comportamiento físico. Ahora mismo, en esta esfera, solo tenemos que recibir las colisiones. Pero si no hay nada que se mueva y llega a este punto, pues nada se percibe como que colisiona. 00:09:55

Tengo aquí el terreno que lo he importado 00:10:15

Ahora si queréis vemos también 00:10:18

Cómo funciona 00:10:19

Tengo este 00:10:20

Que tiene otro tipo, que ahora veremos 00:10:23

De Collider, que es este Mesh Collider 00:10:25

Que es más avanzado 00:10:27

Ahora vemos eso 00:10:28

La esfera, para que tenga sus comportamientos físicos 00:10:30

Está ese componente que se llama 00:10:34

Rigid Body 00:10:36

Y que por defecto 00:10:36

Y por eso parece además que se mueve por sí solo 00:10:39

Cuando reproduzcamos el juego 00:10:42

tiene marcada la gravedad 00:10:43

para que se use 00:10:45

hay una sección 00:10:47

en los project settings 00:10:49

igual que veíamos el input manager 00:10:50

por ejemplo, que es el de físicas 00:10:53

está la física 2D, que ahora mismo no se interesa 00:10:55

y las físicas 00:10:57

aquí es donde se establece 00:10:59

y por defecto viene la gravedad 00:11:01

que en la física existe 00:11:02

o es el convenio que hay 00:11:05

sobrepasa un poco mis conocimientos 00:11:06

pero que yo sé, y esto lo veremos en más temas 00:11:09

porque es importante este número 00:11:11

que corresponde con el menos 9,81, ¿vale? 00:11:12

Si buscáis en internet veréis que este número, por lo que sea, que no conozco, 00:11:16

está relacionado con la fuerza gravitatoria, ¿vale? 00:11:20

Si en algún momento iniciáramos un juego en el que estamos en la Luna 00:11:23

y queremos que la gravedad se disminuya, aquí podríamos poner el valor de gravedad de la Luna. 00:11:28

Es decir, esto se puede ajustar aquí, ¿vale? 00:11:32

Entre otros factores que también se habla en el tema, como este layer collision, 00:11:35

Para determinar qué capas colisionan con otras independientemente, las layers son estas, lo veremos también más adelante, diferentes separaciones o segmentaciones que podemos hacer por elementos. 00:11:40

Y bueno, aquí podemos hacer que unos elementos colisionen con otros, pero otros no, y así ir discriminando quién lo hace con qué. Igualmente, hay otro factor que es importante cuando ahora hablemos, que es, si os recordáis, el último día dijimos, los movimientos por el transform se hacen en el método update, 00:11:53

pero los de física lo haremos con el fix update que no necesita ese time delta time del que hablábamos 00:12:19

para regular la velocidad o la potencia de reproducción del ordenador 00:12:25

porque aquí ya está establecido que el intervalo de ese tiempo de ejecución sea este. 00:12:33

Entonces, bueno, pues son distintos elementos aparte de otros muchos que hay sobre físicas 00:12:40

pero que en principio no hay que tocar porque ya viene configurado para que funcione correctamente. 00:12:47

Hay algunos que sí son interesantes, pero bueno, son más avanzados, como la velocidad de penetración 00:12:55

que permite, bueno, porque si una colisión es muy rápida, pues haya un tiempo de detección 00:13:00

para que evite que traspase elementos por ser muy rápido, ¿vale? 00:13:07

Pero bueno, vamos con lo básico. 00:13:11

Cuando ponemos este RigidBody, como usa la gravedad, si le damos a Play a la reproducción, 00:13:13

Vais a ver que la bola cae y atraviesa. Veis que está la bola, cae y hay un collider. Importante, porque si no hay colliders tampoco se detectan, pero hay un collider en la esfera y otro en el terreno. 00:13:17

Y veis que se visualiza. ¿Por qué no lo hace? Muy simple, importante. Que porque veamos aquí un elemento y parezca que el elemento está aquí, realmente el que regula y ajusta todo lo relacionado con esas colisiones es esta malla verde que está relacionada con el collider. 00:13:29

Por tanto, si la he movido y deja de estar asociada a ese elemento, pues veis que la colisión no se da como lo esperable. Ahora sí, ahora tanto la malla visual como la de colisión se ajusta y veréis que ahora cae por fuerza de la gravedad, no hay ningún código de momento que mueva esta bola y se queda ahí plantada. 00:13:45

La velocidad de cómo cae, igual que sucede en el mundo 00:14:03

Se regula, de momento el collider me queda ahí 00:14:10

Se regula con parámetros del RigidBody 00:14:14

Y lo más importante, aparte de que se puede desactivar la gravedad 00:14:17

Si yo la desactivo, pues le doy a play 00:14:21

Y como no hay gravedad, pues este objeto, si hubiera otra bola 00:14:22

O choco hacia abajo, pues habría una colisión 00:14:26

pero en sí no hay fuerza de la gravedad 00:14:32

por eso no cae 00:14:34

luego también veremos que hay otro que es para 00:14:35

aunque tengan gravedad 00:14:38

se queden fijos a la espera 00:14:41

de que a lo mejor, por código digamos 00:14:45

ya no es kinemático y se active 00:14:47

por ejemplo en Angry Birds 00:14:48

por decir un ejemplo, no es exactamente esto pero creo que 00:14:50

ayuda a entenderlo, cuando tenemos un pájaro 00:14:53

en el tirachín de Angry Birds 00:14:55

hasta que no soltamos 00:14:56

no se aplica la fuerza 00:14:58

Pues a lo mejor está en kinemático hasta que de pronto decimos, vale, ya, deja de ser kinemático y usando la gravedad y todas las fuerzas que tengamos, pues ya sueltas y adquieres la fuerza física que se esté otorgando. 00:15:00

entonces el RigidBody 00:15:13

voy a dejarlo como viene por defecto 00:15:16

que es que funcione con normalidad 00:15:18

y con gravedad, están estos tres parámetros 00:15:19

bien explicados en el tema 00:15:22

pero que bueno, la masa 00:15:24

probablemente a nivel físico 00:15:25

tiene muchos peros lo que digo 00:15:28

pero sería el peso 00:15:29

si algo tiene una masa grande 00:15:31

tiene un peso elevado 00:15:33

aparte de que tenga esta masa hay otro parámetro 00:15:35

otros dos 00:15:37

que son el Drag y el Angular Drag 00:15:38

La masa es influyente también, por ejemplo, cuando vayamos a aplicar fuerzas por código, 00:15:43

como hacíamos con la nave, al darle a la W vaya hacia adelante, 00:15:48

según esta masa la fuerza costará más que empuje o no, como si nosotros estuviéramos aplicando la fuerza. 00:15:52

Pero hay otros dos variables, que son este drag y este angular drag, 00:16:00

que son la resistencia, por un lado, al aire y la resistencia a los giros, a las rotaciones, 00:16:03

que dependiendo de qué valores pongamos, si no tienen ninguna resistencia, 00:16:08

Y hay vídeos que hablan de esto en el tema, que independientemente del peso o de la masa, mejor dicho, que tenga un material, lo importante es la resistencia que tenga el aire. 00:16:12

Y está el experimento, supongo que lo habéis visto, del martillo y la pluma, que es en una sala en la que ninguno de los dos elementos tiene resistencia al aire, o tienen la misma, a la misma velocidad, aunque tengan distintas masas. 00:16:23

Pues está este parámetro que lo que hace es, digamos, la resistencia del aire en el sentido de este aire que tenemos aquí en medio y que es invisible, cuánta resistencia, cuánta oposición al movimiento va proporcionando y por eso lo va frenando. 00:16:34

¿Vale? Veis que aunque está a la masa de 1, cae mucho más despacio y si empieza a subirlo incluso se detiene porque hay un aire aquí, hay una fuerza en el ambiente que lo detiene. 00:16:48

Lo mismo sucederá con el angular drag. Esto lo veremos cuando esta bola la rotemos y esto va a suponer que la bola se detenga antes o no. 00:17:01

No es la fricción de los materiales, que esos son los materiales físicos que también influyen, sino la resistencia, digamos, del ambiente, del aire. 00:17:10

que no solo por subir la masa 00:17:17

va a caer más rápido 00:17:20

como hemos visto, todo es en conjunción 00:17:22

con la resistencia que también hay en el aire 00:17:24

pero sí que es importante 00:17:26

por ejemplo, para aplicarle fuerza a más masa 00:17:28

más cuesta mover un elemento 00:17:30

a lo mejor luego se detiene antes o no 00:17:31

según esta resistencia, pero también 00:17:34

influye en las masas 00:17:35

entonces bueno 00:17:37

por defecto vais a ver que una bola 00:17:40

puede caer tal que así 00:17:41

además esto también es 00:17:43

interesante 00:17:45

porque bueno, ya vais viendo 00:17:48

también motores de físicas, etcétera 00:17:52

que los 00:17:53

los software de modelado 3D 00:17:55

tienen simuladores de físicas 00:17:58

para aplicar fuerzas, etcétera, pero 00:17:59

la interactividad que tenemos en Unity no es algo que teníamos 00:18:01

en esos software, por tanto 00:18:04

oye, se abre el abanico de 00:18:06

opciones, ¿verdad? Y ojo, RigidBody 00:18:07

va a ser el componente sobre el que aplicamos 00:18:10

las fuerzas, es decir, si queremos que un objeto 00:18:12

al darle a una tecla 00:18:14

se le aplique una fuerza, ¿vale? 00:18:15

Que no es lo mismo mover con el transform 00:18:18

como hacíamos el otro día con el transform translate 00:18:20

que es que vamos cambiando los parámetros 00:18:21

como hacemos aquí, ¿vale? Esto es lo que hacemos 00:18:24

con transform translate, básicamente por código 00:18:26

pero hacemos esto. O 00:18:28

cambiamos la escala, o cambiamos 00:18:29

la rotación, ¿vale? Pero estamos 00:18:32

cambiándolo en este 00:18:34

componente transform. Con el RigidBody de lo que 00:18:34

se trata es un poco diferente 00:18:38

que es aplicar fuerzas que simulan la realidad 00:18:40

¿vale? 00:18:42

Vamos a ello. Hay otro elemento muy importante, que es que aunque está todo como configurado, y vais a ver que cae la bola y choca y se queda ahí, porque no hay nada más que esté ocurriendo, no estamos dando más fuerza, entonces la bola sigue teniendo gravedad, la detiene esta tabla, porque la tabla, aunque tenga un mesh collider, no tiene un rigid body, y también esto lo pone mucho en el tema. 00:18:45

Si hay un Collider, un GameObject que tiene un Collider, pero no un RigidBody, pues es una pared, es estático, no tiene comportamientos físicos. Detecta colisiones y está ahí para detenerlo. Entonces, por defecto, esto funciona como un suelo inamovible. Y lo hacemos rápido. 00:19:11

Si yo le dijera que esto tenga un RigidBody 00:19:28

Bueno, se lo he añadido durante el play 00:19:31

Ya sabéis que durante el play lo que añadamos no funciona 00:19:34

Pero si le doy a este RigidBody 00:19:38

Simplemente vais a ver que se caen tanto bola como tabla 00:19:40

Porque tienen la gravedad 00:19:46

Si yo desactivo esta gravedad 00:19:47

Y aquí vienen cosas divertidas 00:19:48

La tabla no tiene gravedad 00:19:50

Llega la bola y la sobrepasa 00:19:53

por algo que es un poco más 00:19:56

intrincado, perdona porque esto 00:19:58

el MES Collider ahora hablamos, voy a poner un 00:19:59

BOS Collider 00:20:02

y ahora veis que tiene esa caja 00:20:02

y ahora sí que cuando llegue 00:20:05

estamos usando el BOS Collider, cuando llegue 00:20:08

la bola, la empuja, como si fuera 00:20:10

un bolo, lo habéis visto, ¿no? 00:20:12

la empuja 00:20:15

y 00:20:16

la choca y le da, ¿vale? 00:20:16

no hay gravedad pero se mueve por fuerza 00:20:19

de 00:20:21

el impacto y la fuerza 00:20:21

que le ha transferido la bola 00:20:25

entonces aquí ya podemos ir pensando en juegos 00:20:26

de bolos, en juegos de lo que 00:20:29

implique físicas 00:20:31

voy a dejar aquí un poco aparcado esto 00:20:33

del Maze Collider, que es el Collider 00:20:35

que viene por defecto en estos 00:20:37

FBX cuando lo arrastremos, porque es un poco 00:20:39

más complejo y probablemente la parte más difícil 00:20:41

de entender de la tarea, pero vamos 00:20:43

a ello. ¿Qué problema hay y por qué 00:20:45

y por qué no puedo 00:20:47

digamos con el propósito del juego que tenemos 00:20:49

y voy a decirle que esto 00:20:51

sí, está bien 00:20:53

¿Qué problema hay? Que yo tengo aquí un agujerillo que voy a usar para que se meta la bola, como si fuera un campo de golf, y cuando se meta, pues ahí ha ganado la tarea, el nivel. 00:20:54

¿Qué pasa? Que los colliders por defecto son formas primitivas. Pues una caja, una esfera, una cápsula... 00:21:08

¿Y qué ocurre? Que si tengo un hueco, ahora mismo, si os fijáis, tengo una caja, pero volvemos a recordar que es independiente lo que vemos visualmente con la forma de esa caja. 00:21:14

Entonces, ahora mismo, por mucho que me empeñe, y lo vamos a hacer, la bola jamás se va a meter en ese... 00:21:27

¡Uy va! A ver, voy a quitarle el Rigid Body, ¿vale? Porque no quiero que el terreno se mueva, entonces me está molestando más que otra cosa. 00:21:34

Quiero que teste la colisión y la bola, pues, choque con ello o no. 00:21:41

Cuando llega la bola, se posa ahí, y bueno, aparte de que la bola no la ajusta de tamaño y no va a entrar, pues porque es un poquito grande, ¿vale? 00:21:45

Voy a cambiar la escala, vinculo todo para que se escale proporcional, 0,2, y ahora, a ver, voy a hacerla un poquito más, la voy a ajustar más, ¿vale? Ahora ya sí tiene un tamaño para que se pueda introducir, ¿vale? 00:21:52

Si yo meto esta bola y estamos en reproducción, podemos comprobar las simulaciones de físicas moviendo los elementos, que cuando soltemos o vayamos operando, subo la bola y cuando suelto, como tiene gravedad, baja. 00:22:06

Esto en tiempo real, en el panel escena, podemos siempre ir testeando y fijaos que cuando se cae, suelto y se cae, porque ahí no hay nada. Reseteo otra vez. 00:22:21

¿Qué sucede? Si os fijáis, el primer problema, que cuando yo me pongo encima de este agujero, digo, pero si hay un agujero, ¿vale? Pero lo he dicho, no se está metiendo, aunque lo ponga ahí, se queda flotando, porque el collider del terreno es un cubo. 00:22:32

Entonces, por eso esta tarea, para huecos, vacíos, geometrías complejas, si queremos que se adapte completamente, existe este otro tipo de collider, que es el que suele venir con los FBX, porque son, se entiende, geometrías más complejas que se adaptan a mallas, ¿vale? 00:22:48

Entonces, bueno, ahí pues hay un elemento extra que tener en juego, que es que los colliders también se van, hay distintas tipologías y unos son más complejos que otros y el BOS Collider a nivel de recursos además consume muy poco y el MES Collider, pues si metemos geometrías, consume más y de hecho, lo pone en el tema, si tiene una geometría vinculada o esa malla, ese collider consistente en malla tiene más de un número de polígonos, 256 de hecho, 00:23:06

pues esta malla se simplifica o empieza a tener comportamientos no deseados. 00:23:36

Por eso también, quizá, es la razón por la que os he proporcionado una malla 00:23:42

que veis que tiene pocos triángulos, con respecto a la de alto poligonaje, 00:23:47

que es la que queremos que se vea, que sobrepasa ese número de triángulos. 00:23:52

Y en realidad, cuando tenemos un collider, ¿qué más me da que haya toda esta geometría? 00:23:57

Si lo que quiero es que detecte, pues oye, que hay un agujero. 00:24:03

tampoco tiene que ser 100% 00:24:06

realista 00:24:08

es decir, no se va a percibir cuando la gambola 00:24:10

se cae si hay un poquito, visualmente 00:24:12

sí, porque los acabados son más finos 00:24:14

las curvas, los biseles, pero a nivel 00:24:16

de Collider, no, por eso 00:24:18

se sacan estas versiones de 00:24:20

más bajo poligonaje, para no sobrecargar 00:24:22

porque al final las físicas tienen 00:24:24

muchos cálculos detrás y para 00:24:26

no sobrecargar la máquina, pues se optimiza 00:24:28

de este modo, ¿vale? 00:24:30

Entonces 00:24:32

nos hemos quedado en la bola 00:24:33

Y hay otro comportamiento muy importante, muy, muy, muy, muy, muy, muy importante, digo muchos muy, porque es uno de los quebraderos de cabeza que hay al principio cuando interactuamos a través de colliders, que es que un collider, digamos, y todos, sucede, bueno, en el mes collider, sí, también sucede, pero con asterisco, todos los colliders van a tener un parámetro desactivado por defecto, que es este del isTrigger. 00:24:36

Están en modo colisión, que el collider funciona como un colisionador 00:25:01

Que es lo que hay ahora mismo 00:25:10

Y tenemos esta bola y choca con el terreno 00:25:11

Que si os fijáis tampoco tiene marcado esto East Trigger 00:25:15

Pero hay que pensar que en ocasiones 00:25:18

Y es otro de los usos que tienen los colliders 00:25:21

Es que gracias a estas áreas verdes asociadas con el collider 00:25:23

Estas áreas que tenemos aquí 00:25:28

que no tienen ni por qué ir asociadas a una malla 00:25:30

yo puedo desactivar esta malla 00:25:33

y si este GameObject solo, de hecho mirad 00:25:34

yo puedo añadir aquí 00:25:36

un Entity, no tiene nada 00:25:38

y decir yo quiero que esto tenga un Boss Collider 00:25:40

aunque no se vea nada, aquí hay un Boss Collider 00:25:42

y fijaos que hay una caja ahí 00:25:45

voy a resetear la posición porque me la he llevado 00:25:47

un poco lejos, tengo aquí un Boss Collider 00:25:49

y 00:25:51

ahí está, un cubo 00:25:52

que no se ve, pero hay 00:25:56

un área que sirve para cosas 00:25:57

O está ahí para algo 00:26:00

Como esto tiene un Bosch Collider 00:26:02

No se ve ningún cubo 00:26:04

Pero fijaos que cuando yo dé a la bola 00:26:05

La bola se queda ahí encima 00:26:07

Esto de primeras no es nada intuitivo 00:26:10

Pero es lo que os he contado 00:26:14

Un Collider sirve para detectar colisiones 00:26:16

Y comportarse como un límite natural 00:26:19

A lo que un Rigidbody se enfrenta 00:26:21

Este Rigidbody está intentando seguir bajando 00:26:24

Por fuerza de la gravedad 00:26:26

Y dices, si que ahí no hay nada 00:26:27

Vale, efectivamente no hay nada, pero hay un collider y como tal se está detectando y está funcionando acorde a ello. ¿Qué sucede? Que los colliders tienen otro uso y este además me viene muy bien. Tienen otro uso que es delimitar áreas para que sucedan cosas. Y el ejemplo lo pongo ahora muy rápido. 00:26:30

Imaginaos que yo quiero, y esta es la lógica que tenéis que meteros en la cabeza 00:26:48

Que es cuando yo llegue con la pelota, consiga que la pelota se meta en este agujero 00:26:54

Vamos a tener que decirle al programa de alguna forma que cuando la pelota se meta aquí 00:26:59

Se active un código o sucede algo que nos pase al siguiente nivel 00:27:04

O que saliera una pantalla que diga ha superado el nivel o lo que sea 00:27:09

Pero que active algo, que detecte algo 00:27:14

Para eso se usan los colliders también, solo que en vez de usarlo en modo colisión, porque aquí vamos a querer que la bola se meta y aunque haya un límite, imaginaos que este cubo lo muevo y lo meto aquí dentro. 00:27:15

Queremos que la bola se meta ahí, pero que haya un área definida que no sirva, que no funcione como un límite físico, 00:27:29

pero sí sirva para detectar que algo, cuando traspasa sus límites o se mete en su interior, pueda desencadenar eventos, puede desencadenar acciones. 00:27:40

Para eso está esto de Eastrigger, y son excluyentes. 00:27:48

Si yo tengo un non-collider así, el software sí va a detectar que está chocando con los límites y, entre otras cosas, lo que hace es que no permite que lo atraviese. Va a haber un método en código que permita detectar estas colisiones físicas, digamos, yo lo llamo así, en plan que respetan los límites físicos de este cubo, en este caso. 00:27:51

si yo en el cubo 00:28:11

no en la bola, en el cubo, porque yo la bola 00:28:13

quiero que cuando siga 00:28:15

si yo la dejara aquí 00:28:17

y la sacara de esta caja y le doy al play 00:28:19

yo no quiero, yo quiero que se siga comportando 00:28:21

con algo físico que tiene límites 00:28:24

pero 00:28:25

sin embargo, este cubo 00:28:26

ahora mismo yo no quiero que tenga 00:28:30

un comportamiento físico 00:28:31

se podría buscar por algún 00:28:33

motivo, pero 00:28:35

este cubo 00:28:37

Lo que quiero es que cuando detecte que se ha metido una bola puedan lanzarse estos sucesos. Si yo a este cubo le digo, no, no, tú no vas a funcionar como un collider, vas a funcionar como un trigger. Trigger en inglés significa disparador. Sirve para lanzar, para servir de excusa, digamos, de detector de acciones. 00:28:40

Vais a ver que el primer efecto que tiene es que cuando doy a play, a nivel físico, no está ahí. 00:29:01

Es como si no existiera, lo ha atravesado. 00:29:10

Pero ojo, que el programa sí ha detectado a nivel interno, de momento, que esta bola ha entrado en esta área. 00:29:12

Y eso es lo que haremos cuando de hecho cojamos y usemos un collider, en este caso un boss collider, 00:29:18

porque de esta forma no viene bien, que vamos a hacer más pequeñito. 00:29:25

Vamos a decirle que esto sea de 0,1 en todas las dimensiones. Un cubito, ¿vale? Que lo que vamos a hacer es meterlo aquí dentro y ahí va a estar. A ver, GameObject, lo vamos a llamar detector, bueno, trigger o como queramos, o meta. Vamos a decir que esto es meta, ¿vale? 00:29:28

Y esto, como trigger que es, va a estar aquí esperando a que alguien lo atraviese o lo toque o lo que sea, pero en ningún momento va a suponer una resistencia física. Simplemente va a servir de disparador, de trigger. 00:29:50

Vale, y voy a llamarlo ahora Disparador. Bueno, no, Disparador no. Sucesos Collider, yo qué sé. Porque voy a enseñaros, también viene el tema, que hay dos métodos, bueno, en realidad hay más, pero hay como dos métodos base, que sirven para trabajar con estas colisiones o con estos triggers, ¿vale? 00:30:03

Imaginaos, yo voy a generar un script que se va a llamar, y lo hago aquí durante el tutorial, que se va a llamar sucesos también, collider, yo que sé, que mata, ¿vale? 00:30:33

Y lo voy a asociar a este cubo transparente, visualmente, pero que tiene este collider, ¿vale? Para que sucedan cosas. Abro este código y aquí está, preparado para trabajar, ¿vale? 00:30:46

Este es el objeto que yo quiero que capte lo que va a ocurrir. También se podría poner a la bola lo que vamos a ir viendo, pero hay que ir midiendo a quién se le pone según quién dispara qué o quién tiene ciertas acciones, ¿vale? 00:30:59

Hay dos métodos, y esto es importante con respecto a algunas de las tareas, no en general, pero de las tareas, que es que penséis siempre que estas llaves engloban, y hablábamos del encapsulamiento en su momento, engloban acciones que se dan en ciertos momentos o que recopilan acciones cuando creábamos un método, etc. 00:31:14

Cuando vamos generando nuevas, imaginaos que yo hago el método, voy a saltar o impacto como en la tarea número uno. Hay que tener bien en cuenta dónde lo declaramos. Es decir, si lo declaramos dentro del update, realmente no se está llamando en ningún momento y se está ejecutando dentro del update. 00:31:32

No es el punto, de hecho pone error. Hay que hacerlo fuera de los tiempos de ejecución, que luego ya cada fotograma, si lo metemos en la date, llamaremos a impacto y ahí buscará el método fuera de estas llaves. 00:31:54

Es un método independiente que se llama impacto y hará lo que tenga que hacer. Lo mismo va a suceder con estos que voy a indicar ahora, que se declaran fuera de los tiempos de ejecución. 00:32:09

Siempre dentro de la clase, ¿vale? Pero como otro método aparte. Esos métodos son los onTrigger, ¿vale? Y vais a ver que luego tienen distintos apellidos, que son el enter, el exit, el stay. Por ejemplo, el enter lo voy a poner aquí. Y tiene muchas cosas, mucha parafernalia ya escrita, ¿vale? Importante que esté esa parafernalia, porque si no, no funciona bien. 00:32:18

Por tanto, cuando pongáis un trigger, dadle a la que queráis, doble clic, que se os crea ya ese método. Alguien ya lo ha creado por vosotros, ¿vale? En alguna de estas librerías, bueno, el MonoBehavior, está este comportamiento de onTrigger, ¿vale? Y de hecho está en Unity Engine, está dentro de esta biblioteca. 00:32:40

¿vale? y por otro lado 00:33:01

lo pongo, ahora vamos discriminando 00:33:04

están los on collision, que también tienen las mismas 00:33:06

etiquetas, enter, exit y stay 00:33:08

la forma más rápida en este 00:33:09

momento para asociarlo con que es esto de 00:33:12

enter, stay 00:33:14

o exit, es lo mismo que hablamos 00:33:16

de cuando usábamos los 00:33:18

input.getkey, que estaba 00:33:19

el getkey down, el getkey up o el getkey 00:33:21

a secas, que dependía de 00:33:24

en el momento en el que se pulsa 00:33:26

si se mantiene la tecla pulsada o si 00:33:27

se suelta y en ese momento es cuando se producía el efecto aquí es un poco igual nosotros imaginaos 00:33:30

que tengo el trigger vale porque esto es un trigger vamos a poder lanzar acciones según 00:33:36

si un objeto el que sea ya veremos que luego gracias a este parámetro podremos incluso 00:33:41

discriminar a qué objeto lanza el trigger y qué objetos no vale pero vamos paso a paso cuando un 00:33:48

Si un objeto atraviesa, entra, mejor dicho, por eso es Enter, este trigger, que es el que tiene este script, y por eso sucede, al tocarlo se activará o se hará lo que ponga aquí. 00:33:54

Por ejemplo, si yo tuviera otro método aquí llamado impacto, lo pongo aquí, lo creo y le pongo el void pertinente y digo cuando un objeto, vamos a hacer la prueba inmediatamente de si esto funciona o no, si yo pongo que impacto, ahí está preparado, aquí es como otro tiempo de ejecución, pero dependiente de, oye, esto ha entrado un elemento en el trigger. 00:34:13

vale vamos a decirle que cuando entre por ejemplo esta bola en este en este cubo que tenemos aquí 00:34:43

que es trigger que es de tipo trigger lo tenemos marcado si no fuera trigger estaríamos usando este 00:34:52

otro vale son dos diferentes que se lancen lo que pone el impacto y en impacto voy a poner un 00:34:59

debate lo como siempre la forma más rápida de comprobar que sucede algo que es trigger activado 00:35:03

activado, ¿vale? lo guardo 00:35:10

¿qué sucederá? 00:35:14

¿vale? que cuando 00:35:16

este objeto detecte que le han entrado 00:35:17

en su trigger, pues va a 00:35:20

ejecutar lo que hay dentro, que en este caso nos lleva a 00:35:21

que la consola muestre 00:35:23

trigger en activado 00:35:25

lo he guardado, le doy a play 00:35:27

voy a poner la bolica un poco más arriba 00:35:29

para que se vea que tarda un poco 00:35:31

y que según entra en el trigger 00:35:33

y una sola vez 00:35:35

¿vale? trigger 00:35:38

activado. Esto imaginaos en la tarea de los obstáculos de la nave, que cuando la nave toque ese obstáculo, ya por código 00:35:39

podríamos decir que el propio pivote, el obstáculo, se destruya. En vez de hacerlo con esa condición de si sobrepasa tal 00:35:49

profundidad se desactive, etc., ya se podría hacer directamente con el trigger. 00:36:03

Y de hecho, ahora en vez de, aparte de que ponga 00:36:08

debug log en impacto, voy a hacer que se destruya 00:36:12

a sí mismo. Cuando ponemos gameObject así con minúscula, significa 00:36:14

que estamos hablando del propio objeto que tiene este código. 00:36:19

Vais a ver ahora que lo que va a conseguir es que cuando 00:36:24

esta bola, y veréis que en todo momento 00:36:27

estaba atravesando la caja, es un trigger 00:36:31

recordad, no hay límites físicos 00:36:34

sirve para detectar que algo entra 00:36:35

o permanece si usa el state o sale 00:36:38

si es el exit, veis 00:36:39

y no sé si os habéis fijado 00:36:41

que lo que hace, fijaos en este que es el que tiene el script 00:36:42

que dice, destruyeme a mi 00:36:45

si algo me entra en mi trigger 00:36:47

al darle a play, fijaos que 00:36:49

lo ha destruido el GameObject 00:36:51

vale, aquí ya 00:36:53

es lo que queramos poner en este 00:36:55

interior, ya 00:36:57

lo que vayamos sabiendo, ya vamos detectando 00:36:59

pues eso, que 00:37:02

acciones que se desencadenan con este evento 00:37:05

voy a hacer otra cosa, voy a quitar esto del destroy 00:37:10

que me servía de ejemplo, que en vez de poner 00:37:12

onTriggerEnter, uso 00:37:14

otro de los 00:37:16

de los onTrigger que había, que es el 00:37:16

onTriggerStay 00:37:19

es decir, stay de permanecer, esto 00:37:21

va a ser igual que cuando poníamos el getKey 00:37:23

sin down o up, vale 00:37:26

el trigger state va a ir 00:37:27

ejecutándose en cada 00:37:30

fotograma que esté el objeto 00:37:32

dentro, pues la orden 00:37:34

en un modo, como una especie de update 00:37:36

pero relacionado con esto que estamos 00:37:38

hablando hoy, vale, si yo aquí pongo state 00:37:40

pues lo que vais a ver 00:37:42

es que ahora impacto puesto, muestra 00:37:44

este mensaje de trigger activado, ahora en vez de 00:37:46

solo mostrarlo cada vez 00:37:48

y solo ese fotograma que se mete 00:37:50

el otro 00:37:52

elemento en ese 00:37:54

GameObject, vais a ver 00:37:56

que va a lanzar ese mensaje múltiples veces 00:37:59

porque en todo rato, y veis que 00:38:00

todo rato 00:38:02

que se esté 00:38:04

ese elemento dentro 00:38:05

de la caja, se va a 00:38:08

seguir, y aquí sigue contando 00:38:10

lanzando ese mensaje 00:38:12

si yo muevo la bola y la saco 00:38:14

fijaos que ahora la he sacado, en el momento 00:38:16

en el que no está dentro, ya no se está lanzando 00:38:18

fijaos que en cuanto 00:38:20

vuelvo a entrar aquí 00:38:22

otra vez se activa, porque 00:38:23

estamos dentro, un trigger state. 00:38:26

Esto imaginaos que entráis en un área de un juego en el que cuando entras en una habitación 00:38:29

tiene que haber un peligro y se activa una luz y el enemigo es más fiero, ¿vale? 00:38:34

Pues se podría delimitar que haya un trigger, un collider, como East Trigger, 00:38:40

dentro de esa área y que detecte que cuando entra tal personaje y esté dentro, 00:38:45

pues está en ese modo alerta. 00:38:48

Cuando sale, es decir, cuando ya no está dentro, pues se desactiva. 00:38:50

existe otro que es el exit 00:38:55

que es un poco lo mismo 00:38:57

¿vale? está ahí 00:38:58

es el tercero, que es cuando sale 00:39:00

¿vale? no pone nada 00:39:03

a ver, vale, bueno, hay un problema 00:39:04

aquí seguramente 00:39:07

y esto cuidado también porque es 00:39:08

importante, que es que los 00:39:11

triggers, atención, que si yo 00:39:13

lo metiera aquí, pues básicamente 00:39:15

está todo el rato 00:39:17

tocando a otro elemento, ¿vale? 00:39:19

que estamos hablando todo el rato de la bola 00:39:21

pero si esto también tiene un collider 00:39:22

y por eso está lo de la matriz que os hablé antes, también entre otras herramientas, pues estaría todo el rato detectando algo. 00:39:24

Si yo, vamos a ver, si yo dejo la caja bien ajustadica para que no toque nada y pongo la bola que cuando entre, 00:39:32

es que está detectando que sale en todo momento y de todos modos, a ver, porque no está haciendo el comportamiento, 00:39:46

Vale, es que no había guardado 00:39:52

Que eso, tened en cuenta que hay muchos tipos 00:39:54

Muchos triggers, que no solo es uno 00:39:56

Hay que discriminarlo cuál sería 00:39:59

Ahora, la bola no se lanza 00:40:00

Ningún mensaje hasta que la esfera 00:40:03

Sale, ha salido 00:40:04

Y trigger activado, se ha lanzado 00:40:06

El mensaje cuando 00:40:08

Bueno, pues cuando ha salido 00:40:10

La instrucción que estamos dando, ¿vale? 00:40:12

Eso solo son triggers, pensad que son 00:40:14

Pues por ejemplo, ponerlo 00:40:16

Para cuando atravesamos una puerta que detecte 00:40:18

que pasamos esa puerta o que cuando cualquier cosa vale con gracias a los colliders podemos 00:40:20

seguir determinando áreas y dibujando áreas vale qué sucede con el otro que tenemos por aquí que 00:40:26

existe otro método vale que también es versátil que es ir a borrar el on trigger de momento bueno 00:40:33

no lo voy a dejar ahí que como no vamos a poner nada no hace nada que es este on collision vale 00:40:41

que también la lógica no la voy a aplicar porque es la misma, 00:40:45

Enter, Stay o Exit, que es cuando choque con ese objeto. 00:40:48

Es decir, yo ahora mismo vais a ver que la bola se queda suspendida. 00:40:53

Bueno, espera, porque igual la he movido. 00:40:57

Lo primero es que para que suceda esto del OnCollisionEnter, 00:41:01

como hemos dicho, no puede ser modo IsTrigger. 00:41:06

Son excluyentes. 00:41:11

Puede ser o modo collider físico o modo trigger disparador. Si lo quito, vais a ver que la bola ahora sí se queda suspendida. Lanzará un mensaje, y ahora mismo no lo hace porque nuevamente no ha guardado, pero si ponemos on collision enter significa que en cuanto otro objeto colisione, no trigger, colisione, tiene que estar sin el trigger activado. 00:41:12

colisione con este objeto, ese fotograma 00:41:35

del contacto, el primero 00:41:37

se lanzará el mensaje, vais a ver que en cuanto choque 00:41:38

PLAS 00:41:41

bueno, pues PLAS no, esperad un segundo 00:41:42

collision enter, impacto 00:41:45

trigger activado 00:41:49

¿por qué no lo hace? a ver 00:41:51

no he guardado y seguramente sea eso 00:41:52

¿vale? en cuanto choque 00:41:55

trigger activado 00:41:58

¿vale? bueno, pero veis que sigue 00:41:59

manteniendo la lógica de 00:42:02

contacto físico 00:42:04

si aquí en vez de decirle 00:42:06

collision enter, digo on collision 00:42:08

stay 00:42:11

es todo momento 00:42:11

digamos que esté tocando 00:42:14

que estén contactando 00:42:16

colisionando los dos objetos 00:42:18

se lanzará el mensaje 00:42:20

¿vale? y ya veis que 00:42:22

en cuanto está ahí 00:42:23

aquí trigger activado 00:42:25

por algún momento está dejando de detectarlo 00:42:28

en algún momento ¿vale? 00:42:30

Porque también tener en cuenta, y esto también es importante, que aparte de que se pueden limitar los contactos, etc., cuando tienes geometrías irregulares, y una esfera en cierto modo lo es, puede que haya momentos que se mueva por física alguna de las geometrías de estos detectores y ya no esté rozando, ¿vale? 00:42:32

Pero bueno, veis que va lanzando de distinto mensaje mientras nota que está colisionando. Como las colisiones se entiende que se colisionan, chocan y no suelen quedarse pegados, pues no funciona tan bien, pero también se podría hacer. 00:42:56

También es verdad que hay ocasiones que la gravedad cuando choca en el rebote ya deja de estar completamente alineada, pero la lógica es esa. Y el exit es lo mismo, pero cuando deja de colisionar. 00:43:11

Guardo. Vais a ver que no se lanza mensaje hasta que lo mueva y se deja de colisionar. Otro. Muevo. Lo veis, ¿no? Esto ya abre, creo, un mundo de posibilidades. 00:43:26

problemas que tiene esto 00:43:42

o conflictos que puede surgir 00:43:45

si estamos usando estos colliders 00:43:46

que forman dentro del 00:43:51

ámbito de la física 00:43:53

se puede hacer, pero existirán 00:43:54

problemas si los objetos 00:43:59

los movemos mediante el transform como sabemos 00:44:01

ahora y queremos que 00:44:03

también reaccionen 00:44:05

a las leyes de la física y a los colliders 00:44:07

¿esto qué significa? igual que hemos visto 00:44:09

ese problema de que la bola se posa 00:44:11

y en cierto momento deja de detectar 00:44:13

ese contacto, si yo la bola 00:44:14

aunque ahora lo estoy haciendo así a la brava 00:44:17

con el transform, por tanto me desdigo un poco 00:44:19

puede haber problemas porque 00:44:21

cuando movemos los objetos mediante 00:44:22

el transform 00:44:25

pueden no estar, ahora hay una inercia 00:44:26

por eso se está moviendo la bola, porque empuja y 00:44:29

ha mantenido la inercia, ahí es donde 00:44:30

el angular drag podría haber detenido la bola 00:44:32

esto ahora lo vemos 00:44:35

pero digamos que hay que discriminar los objetos 00:44:36

que vamos a usar mediante 00:44:38

lógicas de físicas 00:44:40

y los que vamos a mover por lógicas 00:44:42

de transform 00:44:44

para que funcione lo más correctamente posible 00:44:45

lo relacionado con las físicas 00:44:48

como son estas colisiones 00:44:51

lo suyo es usar métodos físicos 00:44:52

también para aplicar fuerzas al rigid body 00:44:55

que se muevan los objetos 00:44:57

¿vale? 00:44:58

como va a ser un poco 00:44:59

largo que escriba todo el código 00:45:04

os voy a enseñar, aquí tenía la otra esfera 00:45:06

preparada y la activo y ahí está, es muy parecida a la que teníamos y lo único, le he subido un poco la masa, no es un trigger porque no queremos que se comporte de manera física, es decir, que choque y he añadido un script que se llama PlayerManager, que os voy a enseñar ahora mismo. 00:45:08

Este PlayerManager, y vais a ver que la lógica es muy parecida a lo que ya hemos visto en la tarea 2 y a lo que hablamos en la última tarea, que es esto del GetComponent, esencial ahora mismo para poder afectar a este componente de RigidBody, porque recordad que menos el transform a todos los componentes que queramos acceder tendremos que llegar de alguna forma. 00:45:29

recordad que esto lo vimos el otro día 00:45:51

pero nada, este es el código 00:45:55

habrá que hacer este GetComponent del RigidBody del objeto 00:45:56

que tiene este script 00:46:01

fijaos, aquí están creados 00:46:02

dos Floats que básicamente lo que hace es capturar 00:46:06

dos Axis que se llaman 00:46:10

VerticalBola y HorizontalBola 00:46:13

estos Axis los he creado yo 00:46:14

como ya hemos visto en la anterior tarea 00:46:17

los project settings 00:46:20

input manager y ahí horizontal 00:46:22

bola, horizontal terreno, vertical bola 00:46:24

y vertical terreno, porque 00:46:26

lo pone en el enunciado, voy a hacer 00:46:28

con el WASD y con la cruceta del teclado 00:46:29

que en unos niveles el WASD 00:46:32

sea el que mueva la bola y en otros niveles 00:46:34

sea la cruceta la que mueva el terreno 00:46:36

en el primero el terreno está fijo 00:46:38

no se mueve, no va a tener fuerza 00:46:40

pero en los otros dos, si miráis 00:46:42

como en lo que se pide 00:46:44

pues si va a hacer que se incline 00:46:45

la modo de balanza 00:46:47

que se incluye la propia 00:46:49

tabla 00:46:52

entonces 00:46:53

lo primero es que para a la bola 00:46:54

en este caso, que es la que tiene este script 00:46:58

lo que queremos es 00:47:00

que mueva el RigidBody, importante 00:47:02

porque de primera no es lo más 00:47:03

intuitivo y de hecho lo han hecho 00:47:06

menos intuitivo en esta versión 00:47:08

2022 con respecto a anteriores 00:47:10

porque en anteriores, si usáis por ejemplo Unity 00:47:11

2020, que por cierto en el tema 00:47:13

6 probablemente demos 00:47:16

un pasito atrás en el software para simplificar 00:47:17

explicaciones, pero bueno, veréis 00:47:20

que los RigidBodies tienen un apartado abajo 00:47:22

de info que te muestran 00:47:23

como las inercias 00:47:26

y las fuerzas de velocidad que tienen 00:47:27

los elementos, las fuerzas 00:47:29

que se le aplican al RigidBody. Pero 00:47:32

si hay un elemento, si hay un componente 00:47:34

perdonad, que gestiona las fuerzas 00:47:36

y por eso hay que asociarlo a ello, es 00:47:38

el RigidBody. Por eso 00:47:40

lo que vamos a hacer es 00:47:42

acceder mediante este 00:47:43

tipo de variable, recordad que aquí poníamos el tipo de 00:47:45

el nombre del componente que tuviera para guardarlo como variable 00:47:49

y luego ya lo capturábamos para su uso, aquí lo vamos a capturar con RB 00:47:54

por ejemplo, luego podremos acceder a 00:47:58

propiedades de este componente RigidBody que no están directamente aquí 00:48:02

recogidas, pero sí pertenecen a lo que está programado dentro de este componente 00:48:06

que entre ellas son, está en el tema, el AddForce 00:48:10

y el acto orque. Bueno, aquí he usado 00:48:13

una de cada para que esté el variado 00:48:15

de cómo se usa, pero al ser una bola 00:48:17

la fuerza sirve para 00:48:19

lo mismo que la rotación, porque al final el rotar 00:48:21

también al final se mueve. Si fuera un 00:48:23

cubo, la fuerza así desplazaría el cubo 00:48:25

y la rotación, a menos que le demos mucha 00:48:27

por las esquinas que tiene en los cantos 00:48:29

pues no giraría, ¿vale? Pero 00:48:31

mirad que en esencia es lo mismo que hacía 00:48:33

un jolanave para moverlo, solo que estamos 00:48:35

usando otros métodos. 00:48:37

Y vamos a analizar esto un poquito 00:48:40

más en detalle, ¿vale? Lo primero 00:48:41

es, igual que el otro 00:48:43

día en uno de los 00:48:45

movimientos el axi lo guardamos en una variable 00:48:47

eso es lo mismo, lo hacemos en el update 00:48:49

¿y por qué en el update? 00:48:51

porque vais a ver 00:48:54

que ahora se está digregando en el update 00:48:55

y el fix update 00:48:57

así dicho rápido 00:48:58

el tiempo de ejecución que habría que usar 00:49:01

para métodos que emplean físicas 00:49:03

¿vale? a diferencia del update 00:49:05

que en cuanto puede 00:49:08

va refrescando y generando más fotogramas 00:49:09

para que sea lo más fluido el juego posible. 00:49:12

El Fixed Update tiene un tiempo predeterminado. 00:49:14

Recordad que esto estaba en Edit, Project Settings, 00:49:17

y en el apartado de Time, que es este que está aquí, 00:49:20

¿qué va a decir? 00:49:26

Cada 0,02 segundos, en este caso, 00:49:27

va a ejecutar lo que haya dentro del Fixed Update, 00:49:30

impepinablemente. 00:49:34

Si el ordenador no pudiera, 00:49:35

porque, bueno, si lo ponemos muy bajito, 00:49:38

Por mucho que nos empeñemos, el ordenador igual no tiene la capacidad. Hay un máximo que podemos marcar antes de que de error o deje de ejecutarse o surjan conflictos. Por cierto, algunos ya habéis tocado el time.timescale y básicamente lo que estaréis cambiando en ese caso es esto. También podéis decir que todo el juego vaya al doble de velocidad o se detenga. Esto se hablaba en el tema anterior. 00:49:40

Lo dicho, tiene un tiempo de ejecución fijo, ¿vale? Para que la física, los cálculos físicos que tienen sean estables, ¿vale? Ahí no es tanto que en cada fotograma vaya cambiando el valor de posición X, tal, tal, en cuanto pueda, sino que aquí tiene que haber cierta coherencia también para que sea estable con este tiempo, ¿no? 00:50:05

Entonces, si os fijáis aquí, y esta lógica es la que también tenéis que ir integrando, es que en el update normalmente lo que vamos a querer es captar las interacciones, porque en cuanto pulsemos una tecla queremos que el sistema ya lo guarde en esa variable, y ya está guardado. 00:50:25

en cuanto toquemos una tecla lo más rápido posible que pueda el ordenador, va a guardar en esta variable las variaciones de input que hagamos. 00:50:44

Y aquí está, guardado como variable global. Y está aquí hasta que se lo pida en la próxima antelación física que haya este FixUpdate. 00:50:51

Por un lado tenemos la captura, lo que nos interesa que sea lo más rápido, y luego los comportamientos de RigidBody, de física, lo ponemos dentro del FixUpdate. 00:51:02

Este ejemplo simple es lo que se espera. Todo luego se puede buscar que sea de otra forma, pero el comportamiento esperable o deseable para hacer inputs que muevan objetos con fuerzas físicas sería así. 00:51:10

capturar el input en el update y luego ejecutarlo en el fix update. Recordad, este addForce sale 00:51:26

porque estamos entrando dentro de las propiedades, en este caso de los métodos, que tiene el RigidBody 00:51:34

ya programado. Entonces cuando ponemos este rb.addForce, como tantas otras ocasiones, 00:51:41

Al empezar a escribir nos ponemos y nos dice qué argumentos espera dentro de estos paréntesis y cuando abrimos el paréntesis puede tener distintos, cuatro sobrecargas y aquí hay distintas formas de aplicar fuerza. 00:51:47

Lo importante normalmente, y en este, aunque hay cuatro, en realidad son lo mismo, 00:52:06

podemos pasarle un vector 3, igual que hacíamos en el Translate, por ejemplo. 00:52:10

Luego, opcionalmente, es otra sobrecarga, podemos decirlo, el modo de fuerza, 00:52:15

porque se puede añadir que las fuerzas sean más explosivas, 00:52:19

que una sea como que coja, que lo sea con respecto a la masa, 00:52:22

que ya tenga ahí, por ejemplo, al dar un salto, pues no sea una aceleración continua, 00:52:27

sino que respete el peso que tiene ya el objeto, y por eso un salto, un impulso, 00:52:31

sería un impulso como tal 00:52:35

hay distintos, separado de comas 00:52:37

force modes 00:52:39

y en vez de un vector 3, si queremos pasar 00:52:40

también los distintos 00:52:43

dimensiones de un vector 3 00:52:45

en realidad, pues también se puede 00:52:47

disgregando cada uno, un poco como 00:52:48

hacíamos con el 00:52:51

translate 00:52:53

y al añadir 00:52:54

fuerza, que es lo que vamos a hacer 00:52:57

pues poner 00:52:59

ese vector que marca la dirección 00:53:01

que normalmente 00:53:03

Para tener direcciones ya normalizadas, recordad que está este forward, este up, este backwards, este right, left, etc., que es este 0, 0, 1. Mirad la descripción, atajo, para escribir vector 3, 0, 0, 1. 00:53:04

Yo aquí podría decir, en vez de esto, esto ya lo hemos visto unas veces, pero está bien siempre recordarlo, que ese vector forward sería lo mismo que hacer esto. 00:53:21

Estábamos diciendo que la fuerza se añada en profundidad, es decir, 0 y 0 no se añade ninguna fuerza, pero en Z se añade 1, es decir, hacia el fondo. 00:53:32

Y luego, aparte, este 1, esta fuerza que se está dando, será más o menos intensa dependiendo del axis. 00:53:41

Si tenemos un teclado será muy intensa porque es pulsar una tecla y pasa de 0 a 1 directamente, a no ser que cambiemos, si recordáis en el Input Manager, la gravedad, la sensibilidad, etc. 00:53:48

¿Os acordáis? Y aparte, con fuerza, que es otro parámetro que podemos nosotros ir ajustando, lo multiplicamos para ajustarlo por la fuerza que nos interese. 00:54:00

Digamos que esto es lo que marca la dirección, esto es lo que marca la influencia del input, 00:54:10

y luego hay un multiplicador siempre que hacemos para, oye, esta fuerza es baja, pues vamos a multiplicarla por más. 00:54:16

En vez de poner aquí la fuerza se podría decir, vale, pues que esto sea 60. 00:54:24

Pero bueno, es más fácil tener un valor independiente que además se puede usar a lo mejor en más elementos 00:54:28

que también tengan necesidad de establecer una fuerza, y se pone así y ya multiplica este vector normalizado, ¿vale? 00:54:33

Y el actor es un poco lo mismo, es con respecto a ese eje y pone forward, ¿vale? Porque lo hace con respecto al eje. 00:54:41

Por tanto, si yo, fijaos en el guismo general del mundo, si yo lo que quiero es que la bola rote a izquierda o a derecha, ¿vale? 00:54:50

Lo que quiero es que rote con respecto al forward, ¿no? Que es la profundidad. Si rota en base a ese z, irá izquierda o derecha. Por eso, paradójicamente, este vector no es lo mismo en el add force que en el add torque. De hecho, están invertidos realmente. ¿Vale? Y luego, bueno, este menos sirve para si la dirección del giro no va en la dirección que queremos, siempre lo podemos invertir, porque esto al final lo que hará es que ese 1 sea un menos 1 en el vector. ¿Sí? 00:54:58

Básicamente ahora si yo guardo este código que lo tiene aplicada la esfera y voy al juego y voy aquí y clico en Game y doy adelante y atrás, 00:55:28

fijaos que la bola ya empieza a tener ciertas inercias. Se mueve de izquierda a derecha. 00:55:43

Importante, esto no sé si lo habréis notado ya, pero para que la interacción las capte tenéis que clicar en Game 00:55:50

¿vale? aunque luego 00:55:58

y estar en game y dais a las interacciones 00:56:00

yo al WASP ahora mismo que es como está configurado 00:56:02

¿vale? pero eso no quita que luego 00:56:04

podáis seleccionar 00:56:06

en el escen y arrastrarlo 00:56:07

ponerlo en otro sitio y clicar otra vez 00:56:10

al game y que vuelva a capturar 00:56:12

las interacciones ¿vale? 00:56:14

si os fijáis, los he puesto públicos 00:56:16

o serializados, no lo sé, para que se vea 00:56:18

la interacción, el axis como 00:56:20

estoy dando a las teclas, de 0 a 1 00:56:22

o de 0 a menos 1, esos valores 00:56:23

intermedios son la gravedad y la sensibilidad 00:56:26

que hablamos el otro día 00:56:28

¿vale? y eso ya tiene influencia 00:56:29

en cómo aplica fuerzas 00:56:32

¿vale? 00:56:33

entonces, bueno, pues 00:56:35

este es el comportamiento para mover la bola 00:56:37

y en los siguientes niveles 00:56:39

voy a los siguientes niveles 00:56:42

para 00:56:44

voy a una de las escenas que ya tengo 00:56:45

guardo, ¿vale? 00:56:48

en este lo que voy a hacer es 00:56:49

con la otra cruceta, porque lo he configurado 00:56:51

así en el input manager 00:56:54

se va a ir moviendo, no la bola, sino la plataforma, es decir, ahora mismo la plataforma, la tengo aquí, es el que tiene este terreno move, el que mueve el terreno, entonces si me meto en ese objeto, en ese código, vais a ver que al final es un poco lo mismo, 00:56:56

Tengo el MoveH, el MoveR, me meto en el... Bueno, recordad el otro día que podía hacer esto de GetComponent o arrastrar, si es serializado, y vais a ver, arrastrar el objeto para que coja el RigidBody de en sí mismo, en este caso. 00:57:17

En realidad está cogiendo a sí mismo, que es la otra forma de llegar a ello. Tengo esta fuerza, en el Update cojo el axis, lo he configurado en este caso en vez de bola, se llama terreno, son otras teclas las que he indicado. 00:57:33

Y añade un torque, en este caso, ¿vale? Porque no quiero que sea una fuerza de desplazamiento, sino que gire con respecto al centro de su gravedad, ¿vale? 00:57:47

Que es el centro de la tabla en sí, pues hacia derecha, hacia la izquierda, multiplicándose por los valores que esté capturando y por el valor de torque que hayamos establecido. 00:57:54

Torque, que es igual que speed o fuerza o lo que queramos, una convención o una variable que creamos para multiplicar por ese valor. 00:58:03

que puede ser, pues si nos parece que está lento, pues subimos aquí, podemos ir y se aplicará mayor torque a esta tabla. 00:58:10

Siguientes cosas. Vamos a hablar de cómo... Vale, ya tengo la bola aquí, ¿vale? Y fijaos... Bueno, la cámara, voy a ajustarla. 00:58:18

Aquí habría que hacer, si nos interesa un seguimiento de cámara, igual que hicimos el otro día, con la tarea me refiero, 00:58:31

y voy a hacer que aún así no se va a ir moviendo con la cámara, que eso se haría con un script que siga a la bola, por ejemplo, 00:58:37

o al tablero cuando gira en los otros niveles, lo voy a dejar ahí para que se vea mejor. 00:58:51

Vale, entonces muevo aquí la bola y voy al agujero y no sigue para adelante. 00:58:56

¿Por qué será? Recordáis que teníamos un cubo aquí puesto, que no es un trigger, si fuera un trigger sí lo dejaría pasar, si ponemos un non-trigger en ese código pues haría algo, ¿vale? De momento esto no lo quiero, de hecho me voy a cargar, bueno, no lo voy a cargar porque igual luego me sirve para explicar lo de la meta, pero bueno, lo desconecto el collider y ahora ya sí. 00:59:04

seguimos, intento llegar al agujero 00:59:25

al agujero, al agujero 00:59:28

y me pongo ahí y 00:59:29

anda, que no se mete 00:59:32

lo que habíamos hablado, esto sucede 00:59:33

porque tenemos puesto un 00:59:36

boss collider que está haciendo una 00:59:38

forma básica de 00:59:40

collider, ¿vale? por tanto este collider 00:59:42

para este caso, no sirve 00:59:44

si hubiera creado esta plataforma 00:59:46

por defecto 00:59:48

con un cubo, no tendría ese agujero 00:59:50

y tendría este boss collider, pero es que, claro, estamos buscando 00:59:52

algo que es un poquito más complicado. Y el FBX que hemos metido de estos, cuando 00:59:54

lo arrastramos, si clicamos, tampoco viene con este Mesh Collider. Hay que añadirlo, 01:00:00

¿vale? Importante, hay otra sección que lo pone en el enunciado sobre cuando importamos 01:00:06

FBX dentro de Unity al dar al GameObject en general, ¿vale? Esto que está, si no 01:00:14

y agregamos los elementos que hay dentro del fbx hay varias secciones que ya iremos viendo que 01:00:20

aquí hay tela para cortar vale pero hay una que nos interesa ahora mismo y está también hecho a 01:00:27

propósito que es el de las medidas de los objetos porque imaginaos este objeto lo hemos hecho en 01:00:32

maya lo hemos hecho en blender lo hemos hecho en otro software de modelado imagino que también ya 01:00:37

habréis tocado un poco de esto pero cada software luego tiene sus propias convenciones de medidas 01:00:43

incluso cuáles son los ejes de dirección del guimón del mundo. 01:00:49

Si habéis usado Blender, el X, Z e Y no están en las mismas direcciones que, por ejemplo, en Maya, ¿vale? 01:00:53

Y la Z en Blender es, si no me equivoco, la vertical y Y es la horizontal. 01:00:59

Entonces eso, según el software, puede generar bastantes conflictos. 01:01:05

Igual pasa con las medidas. 01:01:09

Si trabajáis en Maya, y para eso está este parámetro de aquí, esta casilla, 01:01:11

solo vamos a tocar 01:01:17

el inspector de los modelos FBX 01:01:19

ahora mismo solo vamos a tocar lo relacionado con el modelo 01:01:22

porque ni estamos rigando, ni animando 01:01:24

ni ahora mismo 01:01:26

usando materiales, ¿vale? 01:01:28

ya os digo, ya lo veremos 01:01:30

si nos metemos en el modelo, lo primero que salen 01:01:31

son dos parámetros 01:01:34

muy interesantes 01:01:36

el primero, ya lo he cambiado, cuando lo metáis 01:01:37

por defecto va a estar con el 1 01:01:40

de hecho, mirad, lo voy a meter igual que estaba 01:01:41

y 01:01:44

dame un segundillo que lo tengo por aquí 01:01:45

vale 01:01:48

aquí, estos son los tres elementos 01:01:51

los voy a arrastrar a ver si me lo admite 01:01:54

otra vez, duplicados 01:01:56

los he duplicado, luego los voy a borrar 01:01:57

pero según meto 01:01:59

una nueva 01:02:01

un nuevo FBX 01:02:03

va a venir con su escala de factor 1 01:02:05

es decir, el valor por defecto que tenga 01:02:07

de ese modelo 01:02:09

de ese software, vale, y luego está el de 01:02:11

conversión de unidades, si dice 01:02:13

Que un centímetro del archivo valga 0,01 metros de Unity, ¿vale? Porque no es lo mismo un software que dice que la unidad es un centímetro que Unity, si recordáis, que el 1 en la escala, en Transform, cuando cambiamos, 1 significa un metro, ¿vale? 01:02:15

Entonces, digamos que hay una variación de 100. 01:02:32

Si meto aquí, por ejemplo, este collider, la geometría sin haberla adaptado, 01:02:35

que es lo que he hecho yo para que mida lo mismo, vais a ver que es enana. 01:02:42

Ahora mismo solo mide un metro. 01:02:46

Recordad que esta cuadrícula es solo un metro y es esto lo que mide. 01:02:49

Podríamos nosotros hacer la bola aún más pequeña y meterla ahí, etc. 01:02:52

Pero hay algo importante y por lo que cuando modeléis, 01:02:56

Si hacéis objetos para un videojuego, modeléis teniendo en cuenta las unidades reales de los objetos, que es que ahora estamos en el mundo de las físicas, y en las físicas influye el tamaño de los objetos. Igual que influye también la iluminación, influye las partículas. 01:02:59

¿Vale? Entonces, aunque aquí ahora intentemos hacer todo a medida, si esto mide solo un metro, esta tabla de madera sería el juego para un roedor, porque sería muy pequeña. ¿Vale? Entonces, ¿qué es lo que habría que hacer? Hombre, podríamos hacer que la escala aumente y lo aumentamos y lo damos por 10, que es precisamente, creo, la conversión que he hecho, etc. ¿Vale? 01:03:14

El problema de tocar las escalas, aparte de que ya deja de estar normalizado en uno y estáis usando otros valores, que a veces ya es un fastidio, es que en ciertos momentos, cuando uséis animaciones basadas en rigs, con esqueletos, etc., tocar mucho lo que son las escalas, la escala en sí no suele tener problema, pero factores como la escala o las conversiones de unidades pueden traer conflictos de que se deformen esos rigs o nuevamente la influencia de la escala. 01:03:38

de los tamaños, alteren lo esperable 01:04:08

en esos RIGs, ¿vale? 01:04:10

Pero si, por ejemplo, venimos de un software que sabemos 01:04:12

que tiene como unidad 01:04:14

convencional el 1 basado en centímetros 01:04:16

como magnitud, en vez de el 1 01:04:18

basado en metros como es Unity, 01:04:20

solo al desmarcarse esta casilla, 01:04:22

¿vale? Lo que va a hacer es que va a haber 01:04:24

una diferencia de 100 del tamaño. 01:04:26

Esto significa que yo... 01:04:29

Ah, perdón. Cuando hagáis 01:04:31

cualquier cambio en una de estas pestañas, 01:04:32

¿vale? Tenéis que bajar y darle a aplicar. 01:04:34

Importante. Y veis que ahora de pronto ese elemento se ha hecho mucho más grande. ¿Por qué? Porque ha aumentado de tamaño. Ahora mide, si nos acercamos, vemos que cada cuadrícula, cada cuadradito de estos pequeños es un metro, ahora medirá del orden de 100 metros, lo cual probablemente también sea muy grande. 01:04:36

Esto es un poco, cuando me entreguéis la tarea, bueno, yo voy a querer que funcione bien. 01:04:56

Que lo pongáis de 100 metros o de 1, bueno, va a influiros en los valores que vais a tener que dar, 01:05:01

en la masa, en las fuerzas, etcétera. 01:05:06

Pero podéis resolverla con distintos tamaños. 01:05:08

Pero me interesa esto para que conozcáis que las medidas influyen en el resultado. 01:05:10

Y luego, esto lo he hecho aquí ya, digamos, que 100 me parecía mucho. 01:05:19

puedo hacer este factor de escala y cuando digo, este que estoy arrastrando aquí, a ver, este que tengo aquí, digo, se ha pasado mucho, 01:05:24

digo, quiero que lo corrija por 0,1. Le doy a aplicar y lo hace del tamaño que era. Es decir, según he dado a la casilla y desmarcado, 01:05:33

era 100 veces más grande de lo que venía por defecto cuando lo hemos visto que era como una tabla de roedor, cuando he dicho eso, ¿vale? 01:05:43

Pues podemos reajustar con ese factor de escala esta conversión. Fijaos que la variación entre dar a esta casilla y desmarcarla es que pasa de un centímetro a 0,01 metros, es decir, hay 100 unidades de diferencia. Por eso pasa de 1 a 100 y con esto pasaría a 10. 01:05:51

Vale, lo dicho, esto del Scale Factor solo lo usaría en caso de que no sea un elemento con armadura o que tenga animaciones en sí. 01:06:09

En este caso, como todas las animaciones que vamos a hacer es porque estamos influyendo nosotros en la malla por fuerzas, etc., nos da un poco igual. 01:06:21

Pero en caso de que haya un esqueleto, como veremos, es mejor tocar la escala o lo preferible desde luego es tenerlo ya en las medidas que nos interesen desde el modelo 3D. 01:06:28

Aunque imaginaos que jugáis al Super Mario y tenéis el modelo a una medida y de pronto queréis con ese esqueleto que sea más grande. 01:06:43

Pues lo que haríamos es aumentar la escala, ¿vale? Pero, bueno, son situaciones diferentes y es sobre todo por evitar conflictos. Por poder se puede hacer todo, pero por evitar problemas que puedan surgir, ¿vale? 01:06:48

Y bueno, me cargo esta plataforma y voy a ir para atrás para cargarme todas las que incluí, que no quiero tener aquí cosas duplicadas, a ver, bueno, a ver si quiere, como he explicado tantas, a ver, fbx, nada, bueno, voy a ir al final porque al final estoy dando a control z y control y, ¿vale? Para deshacer. 01:07:00

Vale, me voy a cargar estos que ha caído después, lo borro y me quedo con los que había importado, ¿vale? Que están ajustados. Para que veáis, en todos quité esto de convertir unidades y en este quería que la tabla del nivel 2 fuera un poco más grande, pues le di un poquito más de Scale Factor. 01:07:28

vale, bueno y este me lo he cargado 01:07:45

vale, que 01:07:47

tenemos que conseguir con 01:07:48

y porque, además en el terreno 1, en el 2 01:07:51

vais a ver que esto no sucede, lo que os había 01:07:53

dicho de que tenemos por un lado el terreno 01:07:55

1 con la malla suavizada para 01:07:57

que se vean los bordes 01:07:59

definidos, básicamente 01:08:00

la que queremos usar a nivel visual 01:08:02

y luego tenemos la que tiene el collider 01:08:04

versión resumida, es decir 01:08:07

con pocos vértices para que no 01:08:09

sobrecargue el ordenador o directamente el collider 01:08:11

no funcione por esta sobrecarga, o haga una reducción que considere, y por tanto nos cargamos un poco el objetivo de intentar tener este agujero ahí accesible, ¿vale? 01:08:13

Vale, pues voy a borrar esta, ¿vale? Y empezamos. Digo, yo quiero que la malla, el GameObject de la malla, sea este que tengo aquí, y lo incluyo. 01:08:27

Yo tengo aquí la malla, que ojo yo, además, como quiero que la profundidad en Z sea hacia donde va la bola, pues voy a coger y le voy a dar una rotación de 180, ¿vale? Para que esté en el horizonte el agujero y no aquí. Simplemente por tener en cuenta que el horizonte, por convención, pues es hacia donde mira este Z, ¿no? 01:08:37

¿Qué sucede ahora? Si os fijáis, tenemos el GameObject, que trae el FB, que es como conjunto, y luego lo que es el hijo, que es el GameObject que tenemos aquí. 01:08:57

Realmente, si os fijáis, este primero que tenemos aquí no sirve para nada, excepto para ser cápsula de lo segundo. 01:09:08

Por tanto, yo podría coger, desempaquetar, me voy al padre, el prefab, desempaqueto, y digo, ala, lo saco de hijo y fuera. 01:09:15

Dejo el terreno 1 que es el que hace que se visualice porque tiene el mesh renderer con la geometría y la malla de visualización, el mesh filter 01:09:25

Pero a esto le falta otra cosa, le falta, porque si ahora doy play, como no hay ningún collider, nada que detenga la bola, veis que se hunde y cae para abajo 01:09:34

¿Qué es lo que voy a añadir? Pues un collider 01:09:42

Como hemos dicho, un Bosch Collider sería lo más eficiente a nivel de cálculo, pero no nos va a permitir meter ese agujero o lo que sea la forma que tenga una malla. 01:09:46

Si voy a... No, Collider no. Ese es para ruedas. Ese es aún más avanzado. Sería el mes de malla, mes Collider. Ahí está. 01:09:56

Cuando son Collider los iconitos vais a ver que son verdes. ¿Y qué puedo hacer con eso? 01:10:05

Tiene un apartadito aquí de la malla que va a usar para ser ese mes, que es en la que podemos arrastrar esta que tenemos aquí reducida. 01:10:11

Entonces yo puedo decir que este es el terreno y aquí cojo la malla, ¿vale? No el GameObject en sí, sino la malla. 01:10:20

Y además, fijaos, como siempre sucede, que aquí está pidiendo un iconito que se corresponde luego con los iconitos de lo que es compatible y lo que no. 01:10:28

Si yo arrastro esta malla, vais a ver que ahora tengo en un mismo objeto lo visual y el collider. 01:10:36

Y el collider es la versión simplificada que vimos. 01:10:43

Veis que tiene este agujero, pero no es el que tiene tanta geometría como este que teníamos aquí. 01:10:46

Es este. 01:10:54

Con esto ya hemos conseguido que la bola, este objetivo que teníamos de que cuando la bola llega al agujero, voy a coger el terreno para que veáis, sí que se va a meter porque cabe en el agujero y lo está respetando. 01:10:55

Y ahí se ha quedado, ¿eh? Ahí está la bola, ahí se ha quedado. Ya podéis hacer un juego de golf, ¿vale? ¿Por qué no pasa más? Pues porque nuevamente ahí hay un límite de esta malla. Y ojo, esto nuevamente en el MES Collider puede venir, ahora vemos algo más, la opción de que permita ser trigger o no. 01:11:13

Como no queremos que atraviese ningún caso, esto nunca va a ser trigger, ¿vale? No lo marcamos. Pero ojo, el otro objetivo es lo que habíamos dicho, queremos que haya un detector aquí de que, ¿vale? Y veis que ya tengo aquí preparadito este cubo, que ahora mismo es muy grande, 0,1, 0,1, y voy a hacerlo pequeño, 0,1, 0,1, ¿vale? 01:11:32

Lo estoy haciendo con el propio Box Collider, los tamaños, etc. También, les hago un segundo, se puede hacer con la escala, ¿vale? Nuevamente, si se puede hacer algo con el propio componente, lo haría antes que con la escala, ¿vale? Y también se queda con ese tamaño. 01:11:55

Voy a activarlo para que esté 01:12:12

¿Vale? Y entonces, bueno, voy a ponerlo 01:12:13

Como a mí me gusta, que es 01:12:16

Oye, pues si es un Boss Collider, en vez de cambiar 01:12:18

Toda la proporción del GameObject 01:12:20

Vamos a hacerlo con 01:12:22

Esta 01:12:24

Con las medidas del propio 01:12:26

Collider. Entonces, ojo, ahora lo que vamos a hacer 01:12:29

Es poner aquí, podría ser incluso más pequeño 01:12:32

Lo importante es que haya algún momento 01:12:34

Que la bola lo atraviese 01:12:36

Atraviese, no queremos que sea un impedimento 01:12:37

Y por eso va a ser un 01:12:40

Trigger, marcado ahí 01:12:41

para detectar los onTriggers 01:12:43

y lo dejamos ahí para que en cuanto 01:12:45

la bola pase por ahí 01:12:47

pues diga, eh, cambia de nivel o eh 01:12:49

lanza el mensaje o eh, lo que sea 01:12:51

importante 01:12:52

y lo he dejado caer antes 01:12:56

si esto lo hiciéramos más grande 01:12:58

en plan, decimos, bueno, el cubo lo meto ahí 01:13:01

y que sea así de grande 01:13:03

ten en cuenta que esto estaría en todo momento 01:13:05

tocando la malla del padre 01:13:07

¿vale? entonces hay que 01:13:09

ajustarlo bien de tamaño 01:13:10

A menos del momento que no estamos haciendo nada para discriminar, ¿vale? Entonces, si no me equivoco y si no lo vuelvo a recrear, este trigger que tenemos aquí preparado, cuando, vuelvo a poner aquí el código, cuando, ahora no es un onCollision, sino que queremos usar el onTrigger, ¿vale? Y el onTrigger enter, solo una vez cuando entre, ¿vale? Cuando entre en ese cubito, se lanza impacto que es trigger activado, ¿vale? Simplemente un mensaje de control con debug log. 01:13:13

ahora vamos a ver que ya con esto 01:13:42

voy a jugar a la partida 01:13:45

aquí 01:13:47

fijaos que tengo la escena preparada para ver 01:13:48

cómo se mete ahí, pongo el 01:13:50

sucesos collider, voy a game 01:13:52

empieza a mover la pelota 01:13:54

se irá acercando por esta parte 01:13:56

la vais a ver 01:13:58

le estoy dando fuerza, fuerza, paro ahí 01:13:59

voy a abrir la consola 01:14:03

para que veáis que en cuanto toque ese 01:14:05

trigger 01:14:07

trigger activado 01:14:07

Aquí hemos puesto trigger activado 01:14:11

En este método que hemos creado de impacto 01:14:13

O meta, o como lo llamemos 01:14:15

Pero aquí podríamos decir 01:14:16

Que explote el juego, que la tabla 01:14:18

Cambie de color, que pasemos de nivel 01:14:21

¿Vale? Que es lo que nos interesa, etc 01:14:23

Lo mismo sucederá 01:14:25

Si creamos otro trigger 01:14:27

Como este, lo hacemos muy grande 01:14:29

Y lo ponemos debajo 01:14:31

Que cuando la bola se caiga por un lado 01:14:33

Y toque ese trigger, también podemos decir 01:14:35

Reinicia el nivel, destruyete 01:14:37

Haz lo que sea, ¿vale? 01:14:39

Eso ya sabemos crear entis o objetos con sus colliders y que capte posiciones o colisiones de objetos que tocan con objetos. 01:14:41

Voy a hablar de algo que se profundiza más en la unidad 4, pero que está esbozado aquí en el enunciado de la tarea 3, que es lo de cambiar de nivel. 01:14:51

Voy a decir que ese onTrigger que ya está en el cubillo este que he puesto dentro del agujero, pues que sirva para cambiar de nivel. 01:15:07

Simplemente cambia el nombre, ahora lo importante es lo que hay adentro. 01:15:19

Como no va a ser un collisionEnter me lo cargo porque quiero que sea en base a onTrigger y aquí estoy haciendo esto. 01:15:21

Importante, importantísimo, porque no es solo para este momento. 01:15:27

Muchas veces hay operaciones, funciones, propiedades que tienen que deber de librerías o de capacidades que no hemos incluido en este script. Y esta va a ser una. Cuando hagamos gestión de escenas, es decir, para poder cambiar entre niveles, para ir navegando o activando distintos niveles o escenas, mejor dicho, yo identifico mucho escenas con niveles, pero son escenas en sí, hay que cargar otra librería, 01:15:29

que es UnityEngine.SceneManagement, así se llama, hay que aprendérselo, ¿vale? Habrá otros, iremos viendo, que son importantes. Esto es esencial porque si no de pronto os ponéis a escribir, ponéis cosas que luego no existen, ¿vale? 01:15:58

Me voy a abrir yo aquí mi chuletilla un segundo para ir más rápido y no tener que pensar tanto y si eso ahora lo enseño, pero prefiero explicaros primero un par de cosas, ¿vale? 01:16:18

Cuando incluimos esta línea de código va a haber una clase importante que es esta que se llama Scene Manager que existe aquí para poner bastantes cosas, bastantes métodos. 01:16:30

Uno de ellos es el de cargar escena, ¿vale? Y aquí vamos a poner uno. Bueno, veis que no da fallo, ¿vale? Si yo esta línea no la hubiera incorporado, da fallo, ¿vale? 01:16:44

Por eso es importante esto de las librerías. Cuando vayamos a hacer algo de gestión de escenas, significa que habrá que usar, habrá que incluir en este script la librería relacionada con el Scene Management, ¿vale? 01:16:55

¿Cómo hacemos esto de la gestión de escenas? 01:17:08

Hay, volveremos también en el futuro 01:17:12

Un menú esencial para cuando acabemos el juego 01:17:14

Y poder compilarlo, es decir, sacar el ejecutable del juego 01:17:17

Que es este file 01:17:20

Aquí, build settings, ¿vale? 01:17:22

Si nos metemos en esta opción 01:17:26

Nos abre otra ventanita 01:17:28

Que, ya os digo, esto es más avanzada 01:17:29

Lo veremos sobre todo en el último tema 01:17:32

Ciertas cosas de aquí 01:17:34

podremos sacar nuestro juego para ordenador para android para web para playstation 4 varias 01:17:35

plataformas vale eso nos hará tenemos que ir configurando historias pero la importante es 01:17:42

que todos los niveles que vaya a tener nuestro juego hay que incluirlos en esta en este build 01:17:48

de escenas vale y cuando decimos build escenas es de un proyecto yo ahora si os fijáis estoy 01:17:53

creando aquí más escenas pero el proyecto sólo va a tener un gestor de build settings así digamos 01:17:58

hecho por defecto a través de un menú vale entonces aquí lo que tenemos que ir haciendo 01:18:05

es ir arrastrando las distintas escenas que van a tener nuestro juego podemos añadir cambiar de 01:18:11

orden y aquí a la derecha veréis también que tenemos nivel 1 nivel 2 nivel 3 nivel 4 son 01:18:17

estas cuatro y al irlas incluyendo incluyendo tendrán un índice vale que empezarán y hablamos 01:18:22

de esto también cuando hablamos de los arrays empezarán por el número 0 la primera escena que 01:18:28

al menos que estipulemos algo diferente la primera escena que se ejecutará cuando lancemos el juego 01:18:34

será esta del índice 0 que se llama level 1 pero en realidad esto de level 1 es porque aquí lo 01:18:39

hemos llamado level 1 si esto se llamará como tutoría aquí cuando arrastro y la pongo aquí 01:18:45

Y la primerita, pues es tutoría, ¿vale? Esto de level 1 es la convención que yo he usado. 01:18:50

Para que el Scene Manager pueda usar o pueda llamar a distintos niveles, tienen que estar incluidos en este Scenes in Build. 01:18:55

Aquí, cuando demos estos botones, será cuando creemos ese ejecutable. 01:19:05

Pero de momento solo nos interesa esta sección para incluir los niveles que vamos a ir usando. 01:19:09

¿Vale? Ahí están preparados. 01:19:15

Lo he puesto en orden con los índices, pero vamos a ver que eso tampoco es muy importante más allá del primero, que es el que arranca el juego, ¿vale? Entonces, yo estoy en el nivel 1 y le doy a play, bueno, o tutoría, ¿vale? Y cuando acabe tutoría quiero ir a level 2, ¿vale? 01:19:16

Para eso lo que podemos hacer es que cuando suceda cierta cosa, ¿vale? 01:19:34

Vamos a usar el SceneManager y su método LoadScene para decirle aquí cuál es el número de índice, 01:19:43

número de índice, esto que tenemos aquí, de la escena a la que tiene que ir cuando llegue ese punto, ¿vale? 01:19:51

Si yo quiero ir al nivel 2, realmente tendré que darle el índice 1, ¿no? 01:19:58

vale, pues vamos a mi nivel 01:20:02

que es este, y vamos a ir 01:20:05

a sucesos collider 01:20:07

que es el objeto que cuando 01:20:09

vuelvo a abrirlo aquí 01:20:11

sucesos collider, ¿por qué no me lo abres? 01:20:12

¿dónde lo tengo? tengo ya aquí un montón 01:20:15

de cosas, aquí, cuando sucesos 01:20:17

collider detecte ese 01:20:19

trigger, llega aquí y dice, vale, estoy 01:20:21

a tu disposición, ¿qué hago cuando entra esa bola? 01:20:23

pues vamos a decir que el 01:20:26

scene manager 01:20:27

manager 01:20:28

loadScene, cargue la escena 01:20:30

de índice 1 01:20:33

¿vale? porque sabemos que 01:20:35

esta es la escena a la que queremos ir 01:20:37

entonces 01:20:39

ya de una forma muy rápida 01:20:40

me vuelvo a poner en 01:20:44

para que veamos como llega la bola 01:20:46

me muevo, me muevo, me muevo 01:20:49

y ta ta ta ta ta ta 01:20:50

y cuando se meta, ¡hala! 01:20:53

ya hemos pasado al nivel 2 y ahora estoy 01:20:55

fijaos aquí en el nivel 2 01:20:57

y ya pues tengo el juego del nivel 2 01:20:58

que es esto, de que muevo la plataforma y la bola gira en base, vamos, se adquiere la inercia en base a él, ¿vale? Esta es la forma rápida para esta tarea de ir incorporando, no dejan de ser números, lo que ponemos aquí, esta forma de cargar la escena, las hay más, ya veremos algunas, pero yo aquí puedo decir que esto sea un int, son números enteros, que se llame número nivel, ¿vale? 01:21:01

Creo aquí una variable y es la que uso aquí, número nivel, ¿vale? Entonces, yo por ejemplo esto puedo hacerlo serializado o público y decirle, guardo, voy y decirle aquí en el propio inspector que el número del nivel al que vaya sea el 4 o al 3, 4 creo que no había, o al 0 y cargará el primero que había en el build settings, ¿vale? 01:21:26

Y entonces, de esa forma, podemos decir hacia qué nivel tiene que ir. 01:21:55

Y ha cargado el nivel 1, que es el mismo, pero el otro que tenía preparado, ¿vale? 01:22:00

A cambio de escena. 01:22:04

Esta es la forma rápida. 01:22:05

Porque, y os voy a abrir el que yo tengo preparado en esta, que hay aquí, bastante más avanzada, ¿vale? 01:22:07

Es la que tengo en el nivel que yo ya tenía creado para que detecte que la bola ha llegado al trigger de la meta, ¿no? 01:22:14

Aquí lo que hacemos es un poquillo diferente, pero es básicamente que si he creado un número que es la escena para ir, que es lo mismo que os acabo de decir, pero he hecho otra cosa que es poner en empleo la variable que se genera como argumento del onTrigger o del onCollision. 01:22:21

¿Qué significa esto? Y la forma rápida de entenderlo es esto, si voy a un collision me pasará lo mismo, solo que en vez de poner other pone collision, pero tenemos que entender que esta variable, si luego en el interior de este método la nombramos, la apelamos a ella, estamos accediendo a información del objeto que está colisionando contigo o está metiéndose en tu trigger, es decir, con el otro. 01:22:44

Si este es el cubo que detecta la meta, gracias a este other vamos a poder decir, oye, pero el otro objeto se llama de tal forma o no, porque si no, con este if no pasa esto. 01:23:08

Cada vez que yo ponga other, aquí dentro, y pongo punto, van a salir propiedades que se pueden usar, como por ejemplo, el nombre de ese otro objeto, el tag, 01:23:23

que son etiquetas que vamos a poder 01:23:36

esto también lo veremos en el tema 5 01:23:38

el tags que podemos ir añadiendo 01:23:40

para ir discriminando 01:23:43

lo que he dicho antes, si ponemos un cubo que está tocando 01:23:43

en todo rato, en todo momento 01:23:46

el collider de la tabla 01:23:48

en todo momento está el trigger lanzándose 01:23:50

o hay un momento ya que se ha lanzado 01:23:52

pero gracias a esto podemos ir discriminando 01:23:54

oye, si el nombre del 01:23:56

gain object del otro, del que está tocando 01:23:58

el nombre es bola 01:24:01

hay que meterlo como string y efectivamente 01:24:02

en el nivel 01:24:04

en el nivel que tengo aquí 01:24:07

tengo este objeto 01:24:09

que es bola, que es la bola 01:24:11

si es ese objeto 01:24:12

que se llama bola el que me está tocando 01:24:15

pues hago este cambio 01:24:17

de escena 01:24:19

si se llama 01:24:19

cualquier otra cosa de la jerarquía 01:24:23

si es cualquier otro del objeto que está tocando 01:24:25

pues no, se está activando 01:24:27

así que se están confluyendo 01:24:28

que hasta que no haya esta entrada en el trigger 01:24:30

No se ejecuta lo de dentro, pero es que aunque haya algo que lo toque, podemos discriminar qué es eso que toca. Y fijaos que aquí tengo otro que si el GameObject, bueno, esto no es dentro de un trigger, pero si el propio objeto que tiene el script se llama precipicio, carga el nivel. 01:24:33

Bueno, esto es un poco más avanzado. Con lo que tenemos aquí ya se puede realizar la tarea. Pero fijaos que hay otra forma aquí, ya os lo cuento, de saber cuál es la escena a la que queremos ir. 01:24:56

es decir, qué variable, qué contenido damos a este sin2o, que es si el objeto que tengo aquí se llama precipicio, al empezar el script, si el objeto que tiene este código se llama precipicio, aquí no estamos hablando de ningún other, sino del propio objeto que tiene el script, se llama precipicio, y efectivamente, si voy a este nivel hay un elemento que se llama precipicio, 01:25:10

¿Qué? Casualidades de la vida 01:25:33

Es ese que os he dicho que se pone abajo 01:25:35

Para que detecte que se cae la bola 01:25:37

Y tiene ese collider que es un trigger 01:25:38

Para que siga cayendo 01:25:40

Y detecte que hemos perdido la partida básicamente 01:25:41

Si este objeto 01:25:45

Que tiene este script 01:25:46

¿Vale? Que se llama precipicio 01:25:48

Si se llama así este objeto 01:25:50

Lo que tiene que hacer es 01:25:52

En la escena 01:25:53

¿Vale? Guárdame 01:25:55

Y es otro de las propiedades, otro de los métodos que tiene el scene manager 01:25:57

Que es, consigue 01:26:00

el número de index de la escena activa, es decir, guardan el scene to go, mira y dice 01:26:02

en qué nivel estoy ahora mismo, y dicen el nivel cuyo index de los build settings es 1, 01:26:08

pues ya tienes este 1 preparado para que sea este el número. 01:26:13

Esto es relevante porque nosotros podemos estar definiendo un número al que ir, 01:26:18

pero de esta forma automáticamente, a lo mejor lo que podemos, si tenemos bien ordenados 01:26:22

en el build settings, los distintos niveles es, al arrancar el nivel coge en qué nivel estoy ahora mismo, ¿no? 01:26:27

Get active scene, es decir, la escena en la que me encuentro ahora mismo, y cógeme el número. 01:26:33

Y digo, cuando llegue a cierto punto, la que quiero que me cargue es ese build index, 01:26:38

pero no que se recargue a sí misma la escena, que es lo que estaría haciendo en este momento, 01:26:44

sino que si le ponemos más uno, para pasar de nivel, cuando la bola toque la meta, pues es que va al siguiente nivel. 01:26:48

¿vale? entonces hay distintos 01:26:54

métodos, esto es lo de siempre 01:26:56

pues que a ver 01:26:58

mirando la documentación de Unity 01:26:59

ya os digo que en el siguiente tema 01:27:02

se habla más de esto, pero si vamos a 01:27:04

sin 01:27:07

manager 01:27:08

Unity 01:27:10

en el API, en la documentación del 01:27:12

API, tenemos distintas 01:27:14

métodos que habría que ir 01:27:16

pues eso, desde crear una escena 01:27:18

porque en cierto momento queremos que se 01:27:20

añade una escena a la que tenemos abierta 01:27:22

o, oye, coge de la escena 01:27:24

que está activa, ¿vale? Esto que estábamos cogiendo ahora 01:27:26

de esta escena activa, pues quiero 01:27:28

que me cojas 01:27:30

el build index 01:27:31

entonces, de getAscendScene 01:27:33

¿vale? Y aparte tiene luego 01:27:36

sus propios parámetros. Quiero que de esa escena 01:27:38

me cojas el nombre, ¿vale? 01:27:40

Entonces, pues ahí se puede 01:27:42

se pueden ir guardando 01:27:44

valores relacionados con la escena 01:27:46

Simplemente que sepáis 01:27:48

que para cargar una escena 01:27:50

Ahora, si no queremos recurrir a los números de, aunque tienen que estar en los build settings también, ahí metido, si en vez del número del índice queremos usar el nombre, también se puede decir un array que sea el nombre del nivel, por ejemplo, level 2 creo que se llamaba, y entonces va a buscar dentro de todos los que haya, level 2, pero era junto, va a buscar dentro de todos los que haya aquí los build settings, el que se llame como eso y cargará ese por nombre, ¿vale? 01:27:51

Entonces yo aquí puedo poner level 2 y ahora sería el que cargaría, ¿vale? 01:28:18

El level 2, no estamos invalidando porque no estamos usando esto del número para la escena, pero estaría ahí, ¿vale? 01:28:24

Lo dejo un poco como estaba. 01:28:33

Y hasta aquí, en el primer nivel ya no deberíais tener dificultades para irlo sacando. 01:28:35

En el segundo hay algún pero más. 01:28:41

En el nivel 1 la tabla está estática y si os fijáis el terreno no tiene ningún script, no está desactivado y por tanto lo que se mueve es la bola, pero en los siguientes niveles lo que se mueve es la tabla, entonces a la que hay que darle el script es a la tabla. 01:28:44

Es la que va a tener, lo que os lo he enseñado antes, de hecho, es la que va a tener, a ver, terreno move, pues eso, el torque. Esto os lo he enseñado antes, el torque que añadirá fuerza para que rote. La bola estará encima y por inercia, ahora es la bola, de hecho, la que tiene su script de movimiento desactivado porque no quiero que se mueva con la cruceta que tengo establecida en el input manager para el movimiento de la bola. 01:29:01

Quiero que sea plenamente solidaria, que reciba la inercia según la inclinación de la tabla. Pero hay un problema, que es que esta tabla, igual que hemos hecho antes, tiene un MES Collider que considera que tiene un agujero para que no pase lo de antes de que no se meta la bola. 01:29:25

¿Qué problema hay? Que para aplicar fuerzas al terreno, y por tanto le tenemos que poner un RigidBody, a diferencia del nivel 1, que no hace falta un RigidBody, va a ser un objeto estático, cuando metemos un MeshCollider, para que coja esta geometría con el RigidBody, el RigidBody va a salir un error que va a implicar que tenga que estar en kinemático. 01:29:46

Si no, veis que no se ve aplicado y no funcionaría. De hecho, si lo quito y le doy a play, o dará error o se sumergirá en la tabla. 01:30:16

¿Veis? Esta bola. Entonces, intentadlo, pero va a haber un problema, que es que es imposible que con un solo GameObject podáis aplicar la rotación en el RigidBody para que se mueva y que el MeshCollider respete el agujero. 01:30:26

Para esto, y es la dificultad y está hecho a posta, normalmente no se llega a estos escenarios porque no queremos mover por físicas algo que tiene una malla más detallada, hay que disgregar en dos elementos esta tabla. 01:30:46

Por un lado, un elemento padre que si os fijáis no tiene nada de geometría, no tiene ni MeshFilter ni MeshRenderer, se podría llamar también MovedorTerreno, que lo que tiene es un RigidBody para efectivamente que este script mueva este RigidBody y haga que se gire, ¿vale? 01:31:04

y luego un hijo, que al ser hijo va heredando la posición de su padre, en el que sí que esté este RigidBody, pero no está el movimiento por código, ¿vale? 01:31:22

Y en este sí que podéis activar un MeshCollider sin el convex, ¿vale? Para que sí que, para que no sea, cuando leáis los apuntes veréis que puede estar en modo convex, 01:31:32

que intenta minimizar o reducir directamente la geometría, 01:31:42

pero nuevamente hace eso de que lo convierte en un elemento que no tiene el agujero 01:31:47

y si queremos que mantenga ese convex, pues hay que añadir un rigidbody que sea de tipo kinemático 01:31:52

y cuando hacemos eso ya no se puede mover por código este rigidbody. 01:31:58

Entonces lo que hacemos es mover ese movimiento de físicas, lo hacemos en un padre y lo hereda el hijo 01:32:03

que es el que sí tiene el collider y la geometría de ese agujero. 01:32:08

Esta es la mayor dificultad, pero sabiendo esto un poco en cuenta y teniéndolo en cuenta, 01:32:14

creo que ya resulta gran parte. 01:32:20

Fijaos que es este tipo de error, los non-convex mescollider con no kinematic rebody 01:32:24

no se soportan desde hace tiempo. 01:32:30

¿vale? entonces hay que ir 01:32:33

bueno pues 01:32:35