Tutoría 5 - DEIM - UT2y3 - Curso 22·23 - 8Febrero

sobre aquí tengo yo abiertas donde dejamos el otro día la ut2 que quiero ver esto que 00:00:00

estábamos hablando vale de los límites y bueno lo dejamos en un punto siendo que hasta aquí más o 00:00:05

menos todos dejasteis en la entrada de la práctica y el problema está en que yo ahora mismo me puedo 00:00:11

ir a otra comunidad autónoma porque me salgo completamente de escenario hoy de los límites 00:00:18

básicamente lo que querríamos es que no suba mucho más de donde acaba el obstáculo porque 00:00:24

si hago esto, pues el juego la verdad 00:00:29

que carece de sentido 00:00:31

y tampoco salirme 00:00:32

del carril 00:00:35

para que me obligue un poco a enfrentarme 00:00:37

a estos 00:00:39

pivotes, entonces 00:00:41

el otro día lo dejamos 00:00:42

en, a ver, que 00:00:45

claro, los límites, a quien habrá que 00:00:47

ponérselo, es 00:00:49

básicamente al movimiento del 00:00:50

jugador, hay otra forma de hacerlo 00:00:52

¿vale? ahora que estamos viendo las dinámicas 00:00:55

también, que es 00:00:57

que se podrían generar en las paredes 00:00:59

que tuvieran un collider y no me dejaran 00:01:00

ni subir ni bajar, es decir, esa sería 00:01:02

un poco la 00:01:04

la opción 00:01:05

low cost 00:01:08

trampera 00:01:11

se podría usar, ¿no? 00:01:12

cuando creamos una primitiva 00:01:14

un objeto de estos básicos que tenemos aquí 00:01:16

la bola, por ejemplo, como lo que habréis hecho con la esfera 00:01:18

ya vienen con su propio collider 00:01:20

que como habréis leído en el tema 00:01:22

los hay de varios tipos 00:01:24

y se ven con esta 00:01:25

aquí no se ve mucho 00:01:27

pero si os fijáis tiene como unos bordecitos 00:01:30

verdes, que ya aprovecho 00:01:32

para deciros que para editar 00:01:34

y ver bien los colliders, aquí en la 00:01:36

ventana escena, podéis poneros 00:01:38

en modo white frame, que se ve 00:01:40

la malla, pero se ve 00:01:42

mucho más destacado lo que es la geometría 00:01:44

que pues con los manejadores 00:01:46

que tenemos aquí 00:01:48

del propio 00:01:49

collider, definimos hasta donde 00:01:52

tiene que detectar que algo 00:01:54

choque con otra cosa, que por cierto 00:01:56

muchas veces, me vuelvo 00:01:58

al modo 00:02:00

normal 00:02:01

muchas veces jugaréis a un juego 00:02:03

y tenéis un jugador que tiene brazos, etc 00:02:06

pero veréis que cuando 00:02:08

choca es como que es 00:02:10

no coincide completamente con el cuerpo, que eso 00:02:11

lo habréis visto en el tema, hasta los Maze Colliders que son 00:02:14

muy caros a nivel de 00:02:16

recursos porque detecta 00:02:18

intenta adaptarse completamente a la geometría 00:02:20

esta malla fuera más complicada 00:02:22

no le cuesta nada y se podría hacer 00:02:24

es cara pero muchas veces 00:02:26

para 00:02:32

identificar en recursos a ese personaje se le pone 00:02:32

un collider de tipo cápsula 00:02:35

por ejemplo 00:02:38

y más o menos coincide con el jugador 00:02:38

pero está claro que a veces va a chocar antes de llegar a la pared 00:02:41

y por eso una vez abriéndote 00:02:44

en un juego que te chocas con la pared 00:02:46

como que choca antes o lo atraviesa ligeramente 00:02:47

porque a veces 00:02:50

se hacen estas formas básicas para 00:02:51

adaptar un poco 00:02:53

al contorno del objeto 00:02:55

también lo habréis visto en el tema que aquí hay un botoncito 00:02:58

dentro de cada collider que si dais os permite 00:03:01

adaptar la forma del collider 00:03:05

de forma visual 00:03:07

cuando lo hacéis se os abre aquí también 00:03:10

en el menú de herramientas, si tenéis una nueva versión de Unity 00:03:13

esta barra de herramientas la tendréis dentro del propio visor 00:03:16

de escena, pero es lo mismo en realidad 00:03:20

Y aquí tenéis, cuando activáis esto, pues tenéis que podéis activar lo mismo que podríais hacer aquí a mano, pero de una forma visual. 00:03:21

Vale, dicho esto, ah, esto podríamos con su collider decir, esto va a ser una pared, voy a hacer una sola pared izquierda, ¿vale? 00:03:30

Y yo digo, bueno, pues hago que la escala en X sea más pequeñita para que sea estrecha, bueno, voy a hacer un morete y lo que me interesa es que esto ocupe bastante en profundidad y en altura. 00:03:41

De todos modos, como la nave, según estamos configurándola, no se mueve, que son los obstáculos, en realidad con ponerlo aquí tampoco tiene que ser mucho más grande, ¿vale? 00:03:56

Entonces, ahora mismo, como tenemos un collider, vamos a ver qué ocurre. Si yo le doy al play y voy a la izquierda, a ver qué pasa, que igual todavía no está fino esto. 00:04:03

Veis que lo atraviesa, ¿vale? Ahora mismo, aunque tenga collider, lo atraviesa. No sé si alguno me podría decir el por qué. Esto es una pared con un collider, ¿verdad? 00:04:15

¿Por qué será? Que es como algo importante tener en cuenta cuando usamos dinámicas. 00:04:25

Porque el objeto no tiene collider. 00:04:30

el objeto no tiene collider 00:04:32

yo voy al objeto 00:04:34

y esta nave 00:04:35

tiene colliders dentro 00:04:37

entonces lo que no tiene es rigidbody 00:04:39

efectivamente, por muchos colliders 00:04:41

que pongamos, si no decimos que un objeto 00:04:44

digamos que es 00:04:45

un cuerpo rígido 00:04:47

pues son colliders 00:04:50

que entre sí se pueden 00:04:52

entender que están colisionando 00:04:54

etcétera, pero a nivel física 00:04:56

no estamos 00:04:57

interactuando con ese 00:04:58

con esos colliders 00:05:01

entonces en algún punto 00:05:03

se lo voy a poner aquí, por ejemplo 00:05:05

bueno, se lo voy a poner dentro del prefab 00:05:06

del padre que tiene todo lo de la nave 00:05:09

en mi caso, si yo le pongo el rigidbody 00:05:11

y esto tiene también algún pero 00:05:13

ahora lo vamos a ver, y le quito la gravedad 00:05:15

porque no quiero que se esté cayendo todo el rato 00:05:17

y ahora cuando le de play 00:05:18

no me equivoco 00:05:20

cuando le de ese play 00:05:21

veis que la atraviesa, porque le estoy dando mucha fuerza 00:05:24

y ahora lo digo también, pero veis que está aquí 00:05:27

y empezando a hacer unos requiebros bastante bonitos. 00:05:29

Eso es porque sí que está chocando. 00:05:31

Lo atraviesa, pero está chocando. 00:05:33

Y esto también es importante, lo que voy a decir. 00:05:35

Cuando estamos empezando a meternos en el mundo de las físicas, 00:05:37

que queremos que los objetos colisionen con otros, 00:05:41

y se detecten, etc., 00:05:43

deberíamos mover los objetos no mediante las propiedades del transform. 00:05:45

Ahora mismo lo que estamos haciendo es que este transform, 00:05:51

que cuando le dé a la A 00:05:54

pues el X se vaya a la izquierda 00:05:56

por ejemplo 00:05:59

pero como si ya habéis visto este tema 00:05:59

3, el de la bola 00:06:02

como se mueve el objeto en esa práctica 00:06:03

ya no es a través del transform 00:06:07

es decir, no es como una mano invisible 00:06:08

que dice, ah, pues 10 a la izquierda 00:06:11

10 a la derecha 00:06:13

que es una de las formas de mover objetos en realidad 00:06:13

aquí 00:06:16

lo que estamos empezando a hacer 00:06:18

y dado que hemos metido en juego 00:06:20

las físicas porque queremos que se detecten 00:06:21

lo que vamos a hacer es 00:06:24

que las propias fuerzas sean aplicadas 00:06:25

al RigidBody y una vez 00:06:28

empezamos a jugar con 00:06:29

el RigidBody 00:06:32

lo suyo es no usar el Transform 00:06:32

se puede usar pero empieza a 00:06:35

son como dos mundos que no deberían 00:06:37

comunicarse, si mueves 00:06:39

el personaje por medio 00:06:41

de físicas 00:06:43

deberíamos añadir 00:06:45

lo que habréis visto en el tema, el UpForce, el UpTorque 00:06:48

en oposición al transform rotate y el transform translate que habíamos hecho, que son un poco similares, ¿vale? 00:06:50

Entonces ahora veremos, ¿vale? Pero importante también que en Rigidbody, si os fijáis, aquí hay una pestañita que está sin desplegar 00:07:00

que se llama info, que ahora veremos cuando usemos dinámicas, es que esas fuerzas que vais aplicando se van a ver aquí, en el velocity, ¿vale? 00:07:06

El velocity a fin de cuentas es como la fuerza que tiene cada uno de los ejes, la fuerza que está teniendo ese cuerpo. De hecho voy un segundo aquí, que tengo aquí preparada por ejemplo esta bola, este juego, y en el objeto que le estamos, en este caso es la bola, que le estoy dando al RigidBody una fuerza para que avance o gire, 00:07:17

yo empiezo el juego y empieza a moverme 00:07:41

vais a ver que yo cuando empiezo 00:07:45

a pulsar las teclas y se mueve 00:07:46

y de pronto cuando yo deje de pulsar 00:07:49

bueno, tiene una inercia 00:07:51

sigue andando hasta que no pare 00:07:53

cuando ya pare por la 00:07:55

propia fricción del terreno 00:07:57

que está costando 00:07:59

que esto es una de las cosas también 00:08:00

veis que se va cada vez 00:08:02

reduciendo 00:08:04

veis 00:08:06

a ir reduciendo la velocidad 00:08:10

vale, aquí tendríamos que subir un poco la inercia 00:08:14

bueno, aquí no estaba aquí toda 00:08:16

la inercia del material 00:08:17

de los objetos que están interviniendo 00:08:19

pero veis que cuando yo voy interactuando 00:08:21

con el Rigidbody, dándole una fuerza 00:08:23

estoy moviendo estos velocities 00:08:25

que es otra forma de mover un cuerpo 00:08:27

aplicando físicas 00:08:29

bueno, vuelvo un poco 00:08:32

a la otra tarea 00:08:33

esto, si 00:08:35

empezáramos a mover el juego 00:08:37

usando fuerzas 00:08:40

una forma de hacerlo 00:08:42

que la nave se vaya aplicando 00:08:44

con fuerzas, podríamos poner aquí un límite 00:08:46

incluso un límite que tenga el box collider 00:08:48

y no renderice la geometría 00:08:51

si desactivamos 00:08:52

su componente mesh renderer 00:08:55

al final lo que tenemos es este límite 00:08:56

que no se ve pero va a existir y va a impedir 00:08:58

que el objeto se salga 00:09:00

entonces yo ahora mismo 00:09:02

ya os digo que cuando mezclas un movimiento 00:09:04

como estamos haciendo aquí con transform 00:09:06

veis que ahí hace como un clack 00:09:08

ahí quedándose, si voy despacito 00:09:10

pues lo detecta, también porque hay que tener en cuenta 00:09:13

que los rigid bodies cuando los vamos metiendo 00:09:17

tienen distintos modos de detección 00:09:20

de esas colisiones, el discreto 00:09:23

que digamos que va como sampleando durante el tiempo 00:09:26

cuando se choca, pero si son movimientos 00:09:29

muy rápidos o muy exagerados 00:09:32

como que podría atravesar la pared 00:09:36

Hay un modo aquí, ¿vale? Que ya os digo que usando Transform suele dar problemas, ¿vale? Pero que ayuda a que detecte que el movimiento es más grave y entonces le va metiendo aún más fuerza. También dependerá del grosor del collider, dependerá de varias cosas, ¿vale? 00:09:37

entonces, en este caso, por ejemplo 00:09:54

tal y como hemos ido configurando el proyecto 00:09:57

lo lógico 00:09:59

a no ser que nos pongamos a meternos 00:10:00

en traducir todo esto 00:10:02

a movimientos de físicas 00:10:04

para la nave, lo lógico 00:10:06

no es usar estos límites de paredes 00:10:08

que ya veis que existen 00:10:10

y de hecho, si luego quisiéramos que los pivotes 00:10:12

que los pivotes 00:10:14

chocaran con la nave 00:10:16

a ver, a ver, a ver 00:10:18

veis que está chocando también 00:10:19

lo está enviando a cuenca 00:10:21

si empezamos a usar físicas ya podríamos empezar a ganar pues eso en realismo de físicas como lo 00:10:23

podríamos hacer usando ese transforme es decir que no detecte límites en el entorno sino que 00:10:33

sea por código no lo que detecte es esas condiciones voy a quitar este vídeo body 00:10:40

no me hace falta dado que estoy moviendo todo con transformó vuelvo al punto y vamos a ver 00:10:46

cómo usar boleanas para este tipo 00:10:51

de cosas 00:10:53

otra cosa, claro 00:10:54

cuando, si no usamos físicas 00:10:57

aunque no usemos físicas, yo en los 00:11:00

obstáculos que se van creando aquí 00:11:01

les puedo ir 00:11:03

aquí lo que pasa es que como están 00:11:05

apareciendo y desapareciendo me van a volver loco 00:11:07

pero si voy a un obstáculo 00:11:09

yo puedo decirle que tenga 00:11:11

me meto en el prefab 00:11:13

me meto en el prefab 00:11:15

y tiene un collider aquí 00:11:18

si ya habéis también leído el tema 3 00:11:19

hay un modo 00:11:22

en el que digamos que es un obstáculo 00:11:23

físico, que es cuando no tiene 00:11:26

marcado este trigger, pero hay otra opción 00:11:28

que es, oye voy a marcar que esto sea 00:11:29

un disparador de acciones, es decir 00:11:31

a nivel físico no hace nada 00:11:33

es decir, lo va a atravesar cualquier 00:11:36

cosa, porque está pensado para que 00:11:38

cuando cruces un umbral de una puerta 00:11:39

donde haya este 00:11:42

límite, vale 00:11:43

pues lance una acción, como por ejemplo 00:11:45

que explote la nave y se reinicie el juego 00:11:47

Es decir, no está chocando contra el pivote, no lo va a empujar, porque no lo está estableciendo como un colisionador como tal, sino que dice, vale, pues cuando se intersequen la nave, es decir, el collider de la nave, que al final es lo que delimita hasta donde llega esa nave, con el collider de este pivote, pues que el juego acabe o se lancen unas partículas o lo que sea. 00:11:49

Esto también es importante, lo del Ease Trigger, que los colliders pueden ser para ser usados tanto como algo físico, que nos ponga un límite físico, o para que detecte que estamos tocando un cierto objeto y ocurra otra cosa. 00:12:10

Ahora seguimos también. Hasta aquí, como siempre, me enrollo mucho, pero ¿qué tal? 00:12:26

Bueno, Jesús Alejandro me dice que si los demás no estáis teniendo problemas. 00:12:32

me veis la pantalla 00:12:40

y me seguís el audio también 00:12:43

si yo lo veo bien 00:12:44

no sé por qué puede ser 00:12:47

voy a darle 00:12:53

a reiniciar 00:12:56

el ordenador porque igual no lo está cogiendo 00:13:02

si es que si está 00:13:04

en la reunión debería estar viendo 00:13:06

a ver 00:13:07

tienes a mi 00:13:09

si es que está viendo el de otra 00:13:11

persona 00:13:19

no sé 00:13:19

qué le tengo yo 00:13:31

bueno, mientras tanto 00:13:33

más o menos me vais siguiendo 00:13:45

todas estas cosas que me enrollo 00:13:46

pero que hay que tener en cuenta 00:13:48

entonces no 00:13:50

no sé, igual tiene bloqueado algún 00:13:57

bueno, el resto 00:14:51

qué tal, me vais siguiendo 00:14:53

a ver que se vaya grabando esto bien 00:14:54

entiendo que sí 00:14:57

no me decís nada 00:15:01

Siendo que 00:15:02

Que todo más o menos 00:15:03

Vale 00:15:05

Entonces, vamos a ver como 00:15:06

Habéis ya explicado ciertas sutilezas 00:15:09

Que hay que tener en cuenta 00:15:12

Y me cargo esta pared izquierda 00:15:14

Vale 00:15:16

A ver que el juego esté marchando bien 00:15:17

Como hacemos para que 00:15:20

Por código no me permita salirme 00:15:25

De estos límites, vale 00:15:26

Sin recurrir a nada físico, sino a código 00:15:27

Que cuando detectes ciertas posiciones 00:15:30

Pues no 00:15:32

No, no me dejes continuar, ¿vale? Yo tenía aquí, voy a meter aquí, le voy a dar un poquito más de tamaño, que siempre me doy cuenta que creo que lo pongo muy pequeñito, ¿vale? Tenemos las condiciones de moverse, de... etcétera. 00:15:33

Lo que vamos a hacer, el planteamiento que hay que hacer, en esencia va a ser que para que se ejecute, aquí tengo comentado la biblia, para que se ejecuten estos códigos se tiene que cumplir cierta condición. 00:15:53

Es decir, a veces es la tendencia pensar, pues cuando llegue a tal coordenada en X, cuando esta nave llegue aquí a X, que de pronto pare la nave. 00:16:07

Y no, es mejor hacer lo contrario, que mientras la nave se encuentre dentro de los límites que queramos, sí se aplique el movimiento. 00:16:21

Porque al final lo que hacemos así es acotar una región de interactividad en vez de estar desacotando, es decir, acotando los límites. 00:16:28

Es mejor decirle, pues muévete cuando estés donde tienes que estar y si no, pues directamente es que no hay translate, no hay nada. 00:16:40

Más que cuando llegues a tal límite que te ocurra tal cosa. 00:16:47

Entonces, lo que vamos a hacer es generar los límites a donde tiene que llegar cada uno de los límites horizontal y vertical 00:16:53

Y para eso vamos a ir viendo las coordenadas que queremos que se apliquen 00:17:07

A ver, que yo aquí tengo un jaleo 00:17:14

Bueno, como siempre, a la hora de declarar variables, lo suyo es hacerlo antes de todos los métodos que se ejecuten, ¿no? Para que sean comunes a todo el código, ¿vale? 00:17:15

Entonces, para decir en qué altura en Y, en qué posición en X, se encuentra cada uno de los límites, ¿vale? Vamos a generar unos float, por ejemplo, a ver, por ejemplo, vamos a decir que por arriba sean 30. 00:17:29

Vamos a ver si yo quiero que cuando la nave llegue a 30, sí, por ahí, que de ahí no pase, que todavía me estoy chocando. 00:17:49

Ahora, pues definido, el límite por arriba 30 y el de abajo, pues cuando llegue a esta posición que tengo aquí, se queda aquí, no baje. 00:18:03

Vamos a ponerle 5, ¿vale? Pues vamos a hacer que el límite de abajo sea de 5. Voy a ponerle 5 aquí, copio y pego para ir más rápido, ¿vale? El de arriba es este y el de abajo es este, ¿no? 00:18:13

Y para x, pues lo mismo, a ver, ¿hasta dónde queremos que se mueva esto? Yo quiero que cuando la nave llegue a 30 en x, veis que hay una simetría, como hemos hecho todo simétrico, lo bueno es que con un solo valor, cambiando el signo, ya tenemos los límites. 00:18:29

vale en una sola variable vamos a recoger las dos dos límites por lo mismo en vez del límite 00:18:55

vertical esto va a ser horizontal y hemos dicho que iban a ser de 30 si no me equivoco esto 00:19:03

significa que hemos dicho que cuando llegue a esos límites ya podemos poner una condición de 00:19:11

no sobrepasas estos 31 altura no bajes de los 5 de altura vale y aparte vamos a hacer unos 00:19:16

booleanos que van a ser 00:19:23

las restricciones van a ser como los 00:19:25

semaforitos 00:19:26

verticales 00:19:27

y horizontales, es decir, si este 00:19:31

semaforito está en true 00:19:33

es decir 00:19:35

el booleano 00:19:36

está activo, en ese caso 00:19:39

vamos a dejar que la nave se mueva 00:19:41

en vertical, ¿vale? 00:19:42

y si ahora genero aquí otro 00:19:44

para horizontal, pues va a ser un poco 00:19:47

el mismo funcionamiento, ¿vale? 00:19:49

Ahora vais a entender mejor lo que estoy haciendo si es que no me entendéis. 00:19:50

¿Por qué? Porque yo lo que voy a ir haciendo es, en cada fotograma, voy a ir revisando que se cumple estas dos condiciones. 00:19:56

Y si no se cumple lo que a mí me interesa para que esté en true, para que deje mover la nave, pues hasta que no cambie la situación va a estar en false. 00:20:06

Vamos a ir viendo. 00:20:13

para eso, para chequear los límites 00:20:14

voy a crear un método aquí 00:20:16

ahora más abajo tendré que seguir especificando 00:20:20

igual que hicimos con rotar nave o mover 00:20:23

que la tengo ya aquí, aquí dentro se ejecutará 00:20:25

cada fotograma lo que vaya diciendo, voy a hacer ahora otro método 00:20:28

vacío porque no quiero que me resuelva 00:20:31

que cuando lea ese método 00:20:34

cuando ejecute ese método me dé ninguna cantidad 00:20:38

simplemente, lo que siempre digo, cuando ponemos un void 00:20:40

Lo que estamos diciendo es que este cacho de código, en vez de tenerlo aquí metido, lo puedo mencionar en varios puntos solo poniendo su nombre. Y aquí dentro, lo mismo que ya hemos hecho en otras ocasiones, voy a ir estableciendo esos límites. 00:20:43

Los límites, a ver, aquí es donde hay que empezar a ver bien qué es lo que queremos lograr y qué no, ¿vale? Y vamos a empezar a hacer los límites horizontales, que creo que va a ser más fácil, es decir, que no se salga por la izquierda o la derecha donde no queramos que vaya, ¿vale? 00:20:57

Vamos a hacer los límites horizontales y los verticales. 00:21:22

Primero vamos a por estos. 00:21:27

¿Y cuál es la condición para que se ejecute el transform? 00:21:30

¿Cuál sería la condición? 00:21:37

Que la nave esté dentro de los límites de este carril. 00:21:40

y básicamente eso 00:21:47

que esté dentro de los límites 00:21:52

me estáis siguiendo verdad más o menos 00:21:53

no sé si voy muy rápido o voy muy lento 00:21:59

yo hasta ahora bien 00:22:02

básicamente hemos preparado los ingredientes 00:22:05

para poner unos límites 00:22:08

entonces en horizontal 00:22:10

vamos a ir deduciendo que hacemos 00:22:14

quiero que si el transforme, es decir, la posición de esta nave 00:22:17

posición en X, que es el eje que nos interesa ahora 00:22:22

en horizontal solo nos interesa X 00:22:26

si esta nave sobrepasa el límite horizontal 00:22:28

es decir, si por la derecha pasa la posición 30 en X 00:22:33

Pues yo no querré que se ejecute esta acción, ¿no? Es decir, lo que voy a hacer es que cuando sobrepase ese límite que he puesto, ¿vale? El semaforito que tengo en activo en true, que significa haz lo que tengas que hacer, ¿vale? Quiero que se vuelva falso hasta que no lo vuelva a establecer como true. 00:22:40

Es decir, de primera es igual 00:23:01

Es decir, es un poco farragoso 00:23:05

Pero cuando esté todo, volvemos a darle una vuelta 00:23:07

Que lo vais a entender 00:23:09

¿Vale? Cuando sobrepasa este límite 00:23:10

¿Vale? Pues el semáforo 00:23:13

Se apaga, ya no se mueve, ya no va a sobrepasar 00:23:15

Ahí. Con esto estamos diciéndole 00:23:17

El límite derecho, ¿vale? 00:23:19

Porque estamos diciéndole que a partir de la derecha 00:23:21

Si es mayor 00:23:23

La posición 00:23:25

Pues ahí el semáforito rojo 00:23:27

Ahora vamos a hacerlo en X, en horizontal, en la izquierda. Como hemos dicho, a diferencia de lo que habrá que hacer con lo vertical, si esto no se cumple, pasa a la siguiente condición, que si el transform de esta nave en X es, en este caso, menor, hacia la izquierda, que el menos, porque era simétrico, recordad que es menos 30, 00:23:29

nos interesa ahora. Si la posición de la nave, es decir, esto no se cumple, está dentro 00:24:02

del límite, pero esto sí se cumple, porque estoy yendo a una posición negativa, más 00:24:07

a la izquierda del límite izquierdo, pues otra vez quiero el semaforito en rojo. Quiero 00:24:14

que este in-limit hour, hour no, horizontal, se vuelva falso, ¿vale? Entonces, hasta aquí 00:24:19

lo que estamos haciendo es solo que cuando 00:24:27

sobrepase ciertos límites 00:24:28

como que el código interprete 00:24:30

que no se puede ejecutar algo, pero 00:24:33

en ningún momento le estamos diciendo 00:24:35

que eso suceda así, porque 00:24:37

aquí esto se ve como 00:24:38

ver nave, que es independiente del chequear 00:24:40

límites, pues va a decir 00:24:43

pues vale, si es que yo en ningún momento estoy determinando 00:24:44

que el semáforo haga que me mueva o no, me voy a 00:24:47

mover sí o sí, si 00:24:49

y con el eje vertical 00:24:50

o el horizontal le meto una interactividad 00:24:53

lo que habrá que hacer es 00:24:54

Oye, solo muévete. Sí. Este, por ejemplo, es el eje vertical. Vamos primero con el horizontal, que es el que estamos preparando. Sí. Y veis que aquí hay millones de condicionales. Bueno, millones. Que hay que ir estableciendo esos límites. 00:24:56

Entonces, si el límite horizontal es igual, ¿vale? Recordad que si es un solo igual aquí, ¿vale? Significa que estamos, como hemos hecho hasta aquí, estamos dando un valor a la variable para que varíe la variable. 00:25:12

Cuando queremos comparar que algo sea de este valor, digo, si esta variable boleana es verdadera, porque el semáforo está en verde para que haga la acción, entonces sí te mueves. 00:25:28

Pero claro, en cuanto sobrepases estos límites es que va a estar falso, ¿vale? 00:25:42

Hasta aquí ya lo que estamos diciéndole, solo muévete mientras el semáforo esté en verde, que por defecto está en verde, hasta que, ojo, te salga de los límites. 00:25:47

Vamos a ver qué pasa hasta aquí. Todavía no va a funcionar como queremos 100%, pero ya algo vamos a notar, ya verás. Juego y yo voy a la derecha y llega un punto que voy a la derecha y ya no, ya digamos que solo puedo ir en vertical y horizontal porque ya no permite que me mueva en horizontal porque el semáforo me lo ha puesto en rojo y porque sobrepasa el límite, pero tampoco me deja volver a la izquierda. 00:25:56

¿Por qué? Porque en realidad lo que hemos hecho es decirle, muévete en horizontal solo si es verdadero, pero claro, aquí de pronto lo he puesto en falso y en ningún momento he vuelto a ponerlo en verdadero, ¿vale? Hay que hacer siempre las condiciones de boleanas, hay que pensar en que, vale, sí, en ciertas circunstancias, pues pongo el semáforito en rojo, pero claro, también habrá que hacer que esto vuelva al verde, ¿no? 00:26:22

Si no se cumple ninguna de estas porque está dentro de los límites, pues oye, si no, lo que quiero es que el semáforo se vuelva verde. Esto como lo está comprobando, cuando no se cumpla esto, verdadero. 00:26:50

Es decir, yo como estoy definiendo, vuelvo aquí, estoy diciéndole que en horizontal solo se mueva cuando sea true, 00:27:15

pues cuando esté dentro de los límites, que vuelve otra vez el semáforo a true, pues sí me deja moverme. 00:27:23

Si no, es que directamente no existe el translate, no lo ejecuta. 00:27:29

Vamos a ver qué pasa, que todavía no va a funcionar, pero ya vamos más cerca. 00:27:32

vale, voy para allá 00:27:36

y nuevamente 00:27:44

no me deja 00:27:45

volver a la izquierda 00:27:47

estoy igual que antes 00:27:50

y el semáforo 00:27:51

igual está en verde, pero si os fijáis 00:27:53

y aquí hay un matiz puñetero 00:27:55

si me ponen un itis 00:27:58

que es que vale, yo he ido a la derecha hasta el 30 00:27:59

pero por la propia inercia 00:28:02

del transform, veis que 00:28:03

se ha pasado del 30 00:28:05

ahora es 30,0133 00:28:07

y por tanto está todo el rato sobrepasando este límite y por tanto siempre es falso, no me deja volver a poner el semáforo en verde, ¿vale? 00:28:09

Entonces, normalmente cuando usamos el transform, porque si usamos físicas, los objetos rebotan y vuelven un poco a la posición dentro del rango, ¿no? 00:28:18

Porque no te dejan sobrepasar la pared y aquí, sin embargo, veis que la condición se sigue cumpliendo para que sea falso porque es superior, se está cumpliendo esto, ¿vale? 00:28:26

Entonces, en este caso, lo que hay que hacer es poner más condiciones. Ojo, si el límite es mayor que X, y el movimiento, esto no sé si lo miramos en su momento, 00:28:36

pero hay condicionales que puede ser más de una condición, es decir, cuando la posición de X sea mayor que el límite y además también otra cosa, pues que se ejecute. 00:29:01

Si no se cumplen las dos, pues no se ejecuta. Esto es, si pongo el doble Y, que si os dais cuenta, siempre que ponemos un condicional tiene dos signos. 00:29:17

Es decir, antes cuando hemos hecho el igual, el comparativo, eran dos signos. Cuando hacemos como condiciones de comparación o sumar condiciones, veis que se duplican los símbolos. 00:29:27

De hecho, para decirle quiero que se cumpla o no, es decir, que se cumpla la condición con una de estas variables, imaginaos que yo ahora mismo le digo quiero que si es mayor de x o, vale, que este era otro de los condiciones, las dos barritas que se sacan con el algerre y el número 1, vale, van sacando barritas y vuelvo a poner barritas así, si yo le digo aquí otra condición, voy a copiar esta rápidamente, vale, 00:29:38

Ahora mismo esta condición se va a cumplir si o esta o esta se cumplen, no tienen que ser simultáneas, es decir, ahora mismo esta línea haría igual porque lo estamos simplificando en esta línea, pero también puedo decirle que se tiene que cumplir esta y esta, ¿vale? Para que se cumpla, ¿vale? 00:30:08

Entonces, esto no me interesa porque ahora mismo esta primera condición no tendría sentido. Bueno, sí, sí tendría sentido porque si... En realidad esta es la que tiene sentido de las dos. 00:30:28

Si le digo que al sobrepasar tanto el límite derecho como el límite izquierdo, si hago las dos cosas, no, al contrario, no tiene sentido porque tendría que ser uno. No se pueden cumplir las dos a la vez porque no puede estar a la derecha del todo y a la izquierda del todo a la vez. 00:30:42

Sería, en todo caso, si una de estas dos se cumple, pues falso. De todos modos, por lo que estoy diciendo esto, no es por esto, es otra forma que se podría llegar para simplificar condiciones o hacer conjuntivas, es decir, que sean condiciones que se van añadiendo distintos condicionantes. 00:30:58

Entonces, ¿cómo va a ser el caso? Yo lo que le voy a decir es, si el transforme en X es mayor que el límite que he puesto a la derecha y además el movimiento horizontal, es decir, el input que estoy haciendo aquí, recordad que teníamos un float, que va a recoger la interacción que estamos haciendo del eje. 00:31:15

que en este caso es 00:31:41

el a es menos uno y el a es uno 00:31:42

os acordáis, ¿no? de que no es un 00:31:45

getButton que es un valor de boleana 00:31:47

de se activa o no se activa y ejecutación 00:31:49

sino que aquí tiene un valor intermedio 00:31:51

de menos uno a uno, ¿no? 00:31:53

si yo le digo que este eje horizontal 00:31:55

eje horizontal 00:31:57

tiene que ser 00:31:59

si es mayor que cero 00:32:01

¿vale? es decir 00:32:03

a ver, si 00:32:05

estoy yendo 00:32:06

más allá del límite 00:32:09

hacia la derecha. Y además, yo le estoy dando un positivo, es decir, le estoy dando a la D porque quiere ir aún más a la derecha. Esto sería de 0 a 1, que es lo que se aplica en positivo en el eje que tenemos ahora es ir hacia la derecha. 00:32:10

Si se cumplen estas dos, falso. Pero si una se cumple y otra no, no se cumple la condición y por tanto salta. Y seguiría saltando. Si aquí hago otra vez esto, pero invertido. Es decir, si ya estoy en el límite izquierdo y además también tienes que estar intentando ir más a la izquierda, que en este caso sería negativo, pues falso. 00:32:25

pero si una de las dos no se cumple, es decir, que yo he llegado a ese límite pero dejo de pulsar la tecla de ir a la izquierda para ir aún más, 00:32:47

pues en ese caso al final llega un momento que, bueno, en un momento no, en el siguiente fotograma se va a convertir en true, ¿vale? 00:32:55

Y entonces ya el semaforito se abre para que, voy al translate, para que me deje otra vez moverme, ¿vale? Vamos a ver, a ver si funciona, 00:33:02

que ya debería, esto está aquí ejecutando 00:33:11

tan ricamente 00:33:13

vale, vamos a ver 00:33:14

en vertical 00:33:17

todavía hace lo que le da la gana 00:33:19

y yo voy a la derecha 00:33:21

y me he pasado de este límite 00:33:23

como antes, el semáforito se ha puesto en rojo 00:33:25

pero como para que el semáforito 00:33:27

siga rojo, tiene que, aunque 00:33:29

no se cumpla esta 00:33:31

si se cumple la otra, va pasando 00:33:32

condiciones para que vuelva a hacerlo 00:33:35

vais a ver que 00:33:36

yo ahora mismo estoy dando a la D 00:33:38

y nada, pero sí me deja ir hacia la izquierda 00:33:40

es decir, cuando yo dejo de pulsar 00:33:43

la tecla D para seguir yendo a la derecha 00:33:45

el semaforito pasa a verdadero 00:33:47

y ya puedo otra vez hacerlo 00:33:49

si no me creéis 00:33:51

que entiendo que es, que por qué no 00:33:53

me vais a creer, también se puede hacer 00:33:55

para comprobar cuando una booleana 00:33:57

es true y cuando es false, recordad que 00:33:59

está nuestro querido debug log 00:34:01

para ir dando mensajes 00:34:03

en el que en todo momento, si ponemos 00:34:04

la variable que queremos comprobar 00:34:07

que en este caso es inLimitOrg, como es booleano 00:34:09

nos va a ir diciendo, pues ahora está en true 00:34:11

ahora está en false, vale 00:34:13

es decir, si yo ahora voy 00:34:15

a la consola 00:34:16

que piense, me ha puesto 00:34:18

una advertencia de un código 00:34:23

nada, si yo le doy al play 00:34:25

va a empezar en true, porque 00:34:28

el efecto lo tengo en true 00:34:29

cuando llegue a la pared y siga pulsando 00:34:30

veis que ahora se ha puesto en false, y sigo pulsando 00:34:34

la D, por eso sigue el semáforo en rojo 00:34:35

pero en cuanto yo suelte, que lo voy a hacer ya 00:34:37

en cuanto suelte la tecla de intentar ir más a la derecha 00:34:39

me ponen true 00:34:42

y si vuelvo a intentar ir a la derecha se me pone false otra vez 00:34:43

porque se cumplen otra vez las dos condiciones 00:34:46

pero cuando suelto una de las dos 00:34:48

de la conjunción 00:34:49

de decir esta deja de 00:34:52

existir y por tanto no se 00:34:54

cumple todo, pues ala, voy a la siguiente línea 00:34:56

hasta el final 00:34:58

voy al otro límite, igual, si yo intento 00:34:59

ir más a la izquierda, false 00:35:02

cuando suelto esa tecla A, ya está 00:35:04

ya tenemos un límite aquí 00:35:06

¿Vale? ¿Hasta aquí qué tal? ¿Veis que al final lo que hay que pensar es qué condiciones damos para que el semáforo me permita hacer la otra acción? Estamos como cruzando un poco acciones. Esto lo voy a quitar. 00:35:09

que ha cumplido su concierto 00:35:23

¿qué tal hasta aquí? 00:35:26

es un poco farragoso 00:35:28

pero es como si escribierais en un papel 00:35:29

para que se cumpla esta condición tiene que 00:35:31

hacerse tal y tal, si un adelardo no se hace 00:35:33

pues entonces sí que lo puedo hacer 00:35:35

pues hay que trasladarlo a nivel código 00:35:37

un poco jaleo 00:35:39

seguramente, pero 00:35:41

¿qué tal? 00:35:42

¿sí? 00:35:46

hasta esto, digamos 00:35:47

a ver, espera que se me esté grabando esto 00:35:48

vale 00:35:50

habíais llegado a algo parecido 00:35:51

habéis visto el uso de los booleanos así 00:35:54

o como que es algo que os está 00:35:56

siendo interesante, digo que igual esto ya habíais 00:35:58

llegado a llegar 00:36:00

que me acuerdo que el otro día teníais como el problema de lo de los 00:36:02

límites, pero bueno 00:36:04

a mí la 00:36:06

parte esta de lo de limitarlo con la 00:36:07

flecha y tal, vamos, con la pulsación 00:36:10

de la tecla, la verdad es que no se me había 00:36:12

ocurrido y no encontré la manera de 00:36:14

sacarlo por booleanos 00:36:16

es lógico, y si yo 00:36:17

llego a esta solución a veces es porque 00:36:20

miro el código de otro juego 00:36:22

o de otras cosas que tengo 00:36:24

que es normal, es que esto 00:36:25

ya entiendo que cuando eres desarrollador 00:36:27

pro, pues claro, ya es que tienes 00:36:30

interiorizada la forma de pensar, pero es que es verdad 00:36:32

que es intentar traducir 00:36:34

oye, pues ya si sigo dando a la derecha 00:36:35

al botón, pues que no funcione 00:36:38

pues hay que trasladarlo a que en realidad 00:36:40

son números, y ya está 00:36:42

¿vale? si queréis hacemos 00:36:44

muy rápido el vertical, que la diferencia 00:36:46

que tiene es que no es 00:36:48

tan directo, en el sentido de que no es 00:36:49

un positivo y un negativo y hay que 00:36:52

relacionarlo con el límite superior e inferior 00:36:54

básicamente 00:36:56

sería lo mismo, lo hacemos rápido 00:36:58

o queréis ya 00:36:59

probarlo vosotros por vuestro lado 00:37:02

venga, lo voy a hacer rapidete 00:37:03

¿vale? importante 00:37:08

también, esto se está comprobando 00:37:10

cada fotograma porque el método lo he puesto 00:37:13

aquí en el update, ¿vale? no olvidéis este 00:37:15

paso, todo método para que se ejecute 00:37:17

aunque lo tengas aquí preparado 00:37:19

hay que decirle en qué momento 00:37:20

se ejecuta. En todo momento está comprobando los límites para 00:37:22

cambiar estos semaforitos, el vertical y el horizontal. Vamos a poner vertical 00:37:26

muy rápido, venga. El vertical, de hecho 00:37:30

mira, voy a copiar esto y vamos a ir traduciéndolo 00:37:34

¿vale? Aquí en el vertical el eje que nos importa es el i 00:37:38

y le decimos si en el eje i es superior al 00:37:42

límite vertical, creo que lo he llamado 00:37:46

si, intento pasarme 00:37:50

de la raya de aquí 00:37:56

y ahora no es la tecla 00:37:56

el eje horizontal el que tengo que tocar 00:38:00

porque si tocas la A y la D 00:38:02

va a decir 00:38:03

si subes y aparte tocas la D 00:38:05

que es para ir a la derecha, no te dejo moverte 00:38:07

hacia arriba, pues no tiene sentido 00:38:10

el eje que ahora nos interesa 00:38:12

es el de la W y la S 00:38:13

que es el vertical, lo teníamos preparado como vertical 00:38:15

si no me equivoco, ahí está 00:38:18

¿vale? si esto lo hago 00:38:19

el límite vertical 00:38:21

que no es el mismo porque 00:38:23

claro, aquí ahora mismo 00:38:24

no se está cumpliendo la condición 00:38:31

no hay nada que le limite, pero es que yo le voy a decir 00:38:33

no, no, tranquilito 00:38:35

que hasta que en este booleano 00:38:37

el límite vertical 00:38:38

no valga true 00:38:40

¿vale? no se va a ejecutar esto 00:38:42

por cierto 00:38:45

bueno, lo pongo 00:38:47

Por cierto, ¿vale? Se puede, cuando es una booleana y queremos que esto sea true, ¿vale? Si ponemos así esto, ¿vale? Una booleana, si está presente esto, se entiende que es que es igual a 1, a verdadero, ¿vale? Lo digo que esto y lo que tenía escrito antes de esto es exactamente lo mismo, ¿vale? Si alguna vez lo encontráis simplificado. 00:38:48

si esto está activo 00:39:11

esta booleana, pues que se ejecute 00:39:14

si no, no, entonces sería lo mismo 00:39:16

bueno, de hecho, mira, lo voy a quitar 00:39:18

para que veas que funciona 00:39:20

entonces, cuando este semáforo sea verdadero, pues sí 00:39:21

puede subir y bajar 00:39:23

¿ahí en esa parte de ahí 00:39:25

no sería más práctico un while? 00:39:28

por ejemplo, en vez de un if 00:39:29

no, porque el while lo que hace es 00:39:30

ejecutar en bucle una acción 00:39:33

¿vale? y que sería 00:39:35

claro, tú lo que querrías decir es 00:39:39

mientras 00:39:41

mientras esa booleana sea 00:39:42

claro, pero 00:39:45

el problema del 00:39:47

el problema del while es que se ejecuta en bucle 00:39:48

dentro de un fotograma infinitas veces 00:39:50

si es necesario 00:39:52

entonces, si tú dices, vale, mientras 00:39:53

esto sea 00:39:56

activo, vale, pues que se 00:39:58

vamos, lo mismo pero con el while, ¿no? 00:40:00

esto al final el problema que va a tener es 00:40:02

que dentro de cada fotograma no hay nada que lo pare 00:40:04

esto se usa mucho pues con las corrutinas 00:40:06

para que no deje de hacer el ciclo vale de cuando activas una rutina y se vaya y lo vas deteniendo 00:40:08

de vez en cuando pero si no es que aquí haces un bucle infinito porque estás sumando cada una 00:40:15

de las vueltas dentro de un fotograma no sé si me explico si yo pensaba que era igual pero 00:40:19

simplemente cuando no tenía que aplicarle más claro es como si pones un foro si tú por ejemplo 00:40:25

ejemplo instancia es algo en un for y le dices for y le pones una condición infinita no claro 00:40:33

si quieres generar cinco instancias en un solo fotograma tienes que usar un bucle que funcione 00:40:38

a la vez es decir que de las vueltas en un solo en un solo caso aquí al final el ir se ejecuta 00:40:45

una vez porque se da la condición pero no está diciendo vuelve a mirar si esto está verdadero 00:40:51

dentro sabes que va dando vueltas infinitas si necesita generar cinco instancias en un solo 00:40:56

momento con una sola condición, pues necesitas 00:41:02

un while que a la quinta 00:41:04

vuelta deje de 00:41:06

estar activo, cosa que no estamos haciendo, ¿vale? 00:41:08

Porque no hay nada que limite dentro de un fotograma 00:41:10

que algo no ocurra. Pero si tú 00:41:12

haces el for, que es un poco 00:41:14

diferente, ¿no? En el for, si os acordáis, 00:41:16

se puede poner que 00:41:18

al dar varias vueltas hay una condición que lo para, 00:41:20

¿no? Bueno, me estoy yendo un poco otra vez. 00:41:22

Entonces, hasta que haga cinco, 00:41:24

aparecen las cinco en el mismo fotograma, 00:41:26

¿vale? Se usa para ese tipo 00:41:28

de cosas, para cosas instantáneas, pero si no 00:41:30

Pones una condición que lo pare, se peta el juego, que es lo que ponía en el primer tema esto de bucle infinito. 00:41:32

Entonces, si no es para un bucle o con una corrutina que lo va deteniendo para que no deje de ejecutarse, 00:41:39

pero hay algo que le está parando para que se ejecute cada cierto tiempo, como en esta corrutina que vimos. 00:41:46

Pues entonces los bucles no te van a servir para esto. 00:41:51

Entonces, si este semáforo está en verde, pues sí que te deja moverte. 00:41:56

Entonces, un poquito lo mismo. 00:42:01

si intento ir para arriba 00:42:02

y sigo pulsando para arriba 00:42:05

que es el positivo de este eje 00:42:07

pues no, chicos, no puede ser más para arriba 00:42:08

si tenemos aquí 00:42:11

el eje Y que está por debajo 00:42:13

¿vale? 00:42:15

y quito el menos porque ahora no es un menos 00:42:17

ahora lo que estoy diciéndoles es el límite 00:42:19

vertical de abajo que hemos puesto, es decir 00:42:21

bueno, creo que 00:42:23

tengo que cambiar porque lo estoy poniendo mal 00:42:24

a ver, espera que me llevan el teléfono 00:42:27

un segundito, perdona, vale 00:42:29

esto lo había puesto como 00:42:31

vert down 00:42:34

ahí lo tengo down 00:42:35

si, vale 00:42:38

y aquí lo había puesto mayor a menos 00:42:40

pero ahora en realidad es 00:42:43

si el i es más bajo 00:42:44

que 5, es decir, si intento bajar 00:42:46

y el eje vertical 00:42:49

esto es que un poco 00:42:50

joder, están pesadas, perdonad 00:42:52

que me están llamando aquí 20 veces 00:42:54

vale, si el eje 00:42:57

vertical yo además estoy presionando para que sea lo negativo vale pues igual falsa y si no 00:43:03

pues entonces si te dejo moverte vale sería lo mismo solo ha cambiado que los límites se 00:43:11

ponen de otra forma pero la lógica es si subo del límite que le he puesto arriba mal y si bajo del 00:43:17

límite que le he puesto arriba mal es decir que le tengan movimientos y además estoy pulsando ese 00:43:23

botón. ¿Por qué? Porque si quitamos esta condición, al final, como por inercia se 00:43:27

pasa de este límite, pues sí se cumple esta condición constantemente y entonces está 00:43:33

en false. Pero cuando yo digo que las dos se tengan que ejecutar, ahí sí que no se 00:43:39

cumple la condición. Porque cuando dejo de pulsar este botón de abajo, automáticamente 00:43:46

o de arriba va a pasar a false 00:43:51

a true, entonces hay un momento 00:43:53

hay una forma de digamos 00:43:55

resetear las condiciones 00:43:56

para que llegue al true 00:43:59

bueno, vamos a probarlo 00:44:00

y si funciona 00:44:03

sin dudas 00:44:05

más o menos ya tendríamos esto en límite 00:44:06

yo voy para arriba 00:44:09

y le sigo dando y ya no sube más 00:44:12

le doy para abajo 00:44:14

y aquí no me está bajando 00:44:15

hemos encontrado 00:44:18

ahí un 00:44:21

a ver 00:44:23

vale, creo que alguna de las condiciones 00:44:24

no la he puesto bien 00:44:28

ah, vale 00:44:29

veis que aquí he dejado que el semáforo 00:44:33

está influyendo al horizontal 00:44:35

y no al vertical, pues estoy mezclando 00:44:37

conceptos 00:44:39

vamos a ver ahora 00:44:41

ahora la programación 00:44:43

es eso, que es un poco 00:44:45

tejiguera 00:44:46

está demasiado definido 00:44:48

vale, subo 00:44:50

bajo y aunque yo le dé 00:44:53

supongo que lo oís, aunque le dé a la S 00:44:55

más, ya nada, cuando suelto 00:44:57

se resetea el semáforo y ya puedo subir 00:44:58

izquierda, derecha y ya lo tengo 00:45:00

perdona, Daniel, no sé si me escuchas 00:45:03

sí, sí, me escuchas 00:45:05

se nos ha cortado en la explicación anterior 00:45:06

se te ha caído internet o lo que sea 00:45:09

se ha desconectado y no 00:45:11

y no hemos visto nada 00:45:12

vale, ¿desde qué punto? 00:45:14

desde este 00:45:22

las verticales 00:45:23

pues eso, básicamente es lo mismo 00:45:24

que habíamos hecho con la X 00:45:27

pero con el eje vertical 00:45:29

y claro, no me estaba funcionando porque aquí 00:45:31

no había dicho que el semáforo estaba 00:45:33

afectando 00:45:35

con el Y 00:45:37

al semáforo del vertical, por eso sí que podía 00:45:38

seguir subiendo o bajando pero no 00:45:41

ir a la derecha o izquierda 00:45:43

entonces hay que tener cuidado con 00:45:45

saber que estamos afectando 00:45:47

aquí el semáforo solo afecta a lo vertical 00:45:49

que es el que 00:45:51

permite esta condición 00:45:52

para que se haga el translate solo arriba y abajo 00:45:55

y luego el horizontal que es el de derecha a izquierda 00:45:57

¿vale? 00:46:00

más o menos 00:46:02

era lo mismo, si me has estado siguiendo en lo de horizontal 00:46:03

vertical es un poco lo mismo 00:46:06

¿vale? 00:46:08

a ver, aquí 00:46:11

vuelvo, voy con vosotros 00:46:12

porque la... 00:46:14

sí, se sigue cayendo, ya se ha recuperado el tema 00:46:15

ahí ya 00:46:18

ya está bien 00:46:20

a ver, por ejemplo Gonzalo y no sé 00:46:21

quién más me lo ha dicho 00:46:24

es que bueno estoy cogiendo el internet 00:46:25

del móvil y como me han llamado yo creo que se ha ido 00:46:30

con la pinza 00:46:32

vale hasta aquí que tal 00:46:33

más o menos la práctica 00:46:36

del tema 2 00:46:37

vueltas y rechibros y 00:46:39

sutiletas más o menos la hemos visto 00:46:41

entera 00:46:44

a mi me ayudaría un poco que 00:46:44

después de que 00:46:47

corrijas subas 00:46:49

los scripts 00:46:51

los tuyos 00:46:53

Vale, yo puedo subir, esto creo que ya lo dije un día, pero en el centro siempre están con que si estas prácticas se hacen el año que viene, pues que si la gente tiene los scripts, bueno, sí, os pasaré algunas cosas, es decir, no voy a pasar todo el ejercicio, pero sí los scripts, es decir, algún script, por ejemplo, este que acabo de hacer de los límites, pues os lo paso para que le deis una vuelta. 00:46:54

que esto luego hay que saber aplicarlo 00:47:17

también a 00:47:20

Unity, aquí por ejemplo 00:47:21

este sería Live Fill 00:47:23

hay que vincularlo, etc 00:47:25

pero así podéis ver un poco 00:47:28

sí, lo subiré 00:47:29

tomo esta tarea y ya está corregida 00:47:32

eh 00:47:34

queréis tener la nota todos 00:47:34

la nota y el feedback es lo que más me interesa 00:47:37

que veáis 00:47:40

pero sí 00:47:41

subiré cosas 00:47:43

De momento voy a esperar un poquito, pero sí. Entiendo que ya la inestabilidad de conexión se ha calmado, ¿no? Vale, ¿dudas hasta aquí o nos ponemos un poco con la 3? A ver cómo lo llevamos. 00:47:45

vamos con la 3 ¿no? 00:48:05

venga 00:48:14

pues 00:48:14

tarea 2 la voy a cerrar 00:48:16

la dejo ahí 00:48:18

vale, tarea 2 acabada 00:48:19

fíjate 00:48:24

que una pregunta hasta aquí 00:48:25

vais entendiendo 00:48:28

un poco como funciona todo, digo que no 00:48:30

que entiendo que a lo mejor 00:48:32

también me pasa que luego 00:48:34

llegar a las soluciones, darle vueltas 00:48:36

y no, pero si que vais entendiendo 00:48:38

lo que hago, ¿no? En plan los pasos y ya 00:48:40

el código se empieza a sonar, todo. 00:48:42

Sí. 00:48:46

Vale. 00:48:47

Que al principio es lo que más abruma 00:48:48

y bueno, poco a poco ya vamos. 00:48:50

Ya vamos viendo la luz. 00:48:52

Ok, venga. 00:48:55

Lo primero que voy a hacer, por si acaso hay dudas 00:48:56

en este sentido, es voy a jugar yo al juego, 00:48:58

¿vale? Para que veáis un poco qué es 00:49:00

lo que se busca, que a veces también está 00:49:02

muy escrito y no 00:49:04

lo tengo muy claro, ¿vale? 00:49:06

Al empezar el juego hay un nivel 00:49:08

que es el 1, ahí lo tenéis cargado, en el que yo lo he puesto con la cruceta derecha, pero hay que pensar que en este juego hay dos controles. 00:49:10

Se podría ir variando según la escena, pero por código vamos a simplificarlo. 00:49:20

Que es que yo tengo la cruceta de la derecha del teclado, las flechas que mueve la bola para adelante, para atrás, de izquierda a la derecha, 00:49:27

Y en este nivel no lo tengo activo, pero ya está preparado, aunque no pase nada, la cruceta AWSD para que gire lo que es el suelo. 00:49:36

Es decir, que no sea la bola la que se gire, sino que la bola se mueva porque hay rotación en el suelo. 00:49:45

El primer nivel, según la tarea, lo que dice es que el suelo no se mueve, es solo la bola. 00:49:50

La movemos con físicas, que es la novedad. 00:49:55

Aquí, si os fijáis, lo mismo que os he dicho antes, al final lo que estamos haciendo es aplicar físicas. 00:49:58

Por eso se están cambiando esos valores que tenemos ahí del Velocity, que el Velocity es la fuerza en un eje que tiene esa física. 00:50:06

De hecho, si usáis 3D o en After Plugins de partículas o de emisión de algo con fuerzas, también va a aparecer este valor de Velocity. 00:50:14

Todo lo que tenga dinámicas físicas se mueve con Velocity. 00:50:25

Estamos aplicando una fuerza que se traduce en una Velocity en tal eje. 00:50:29

Entonces, a ver 00:50:33

El juego sería 00:50:36

Que yo estoy moviendo la bola, no el suelo 00:50:38

Y llego a este agujero y cuando me consigo meter 00:50:40

Cambio al segundo nivel 00:50:42

En el segundo nivel, yo aunque mueva la cruceta 00:50:44

De la bola, no pasa nada 00:50:46

No le he puesto ningún speed a la bola en este caso 00:50:47

Para que se mueva 00:50:50

Lo que sí es que la otra cruceta, digamos 00:50:51

De la WSD 00:50:54

Haga que haga un torque 00:50:55

Una modificación de la torsión 00:50:58

De esta tabla 00:51:00

y claro, la bola tiene un rigid body 00:51:02

y un rigid body 00:51:05

pues se va moviendo porque es una esfera 00:51:07

la gracia de aquí 00:51:09

es que ya estamos jugando con 00:51:11

como el elemento se mueve 00:51:13

sin mover el elemento, sino moviendo otro 00:51:15

que es la tabla, una vez 00:51:17

una vez tengamos 00:51:19

esta bola 00:51:21

aquí pasaremos a un tercer nivel 00:51:24

y cuando se cae 00:51:25

veis que además se reinicia el juego 00:51:27

lo voy a hacer de modo fácil que es 00:51:29

darle un poco de inclinación 00:51:31

Voy a completamente 00:51:32

A ver, a ver, ahí 00:51:35

¿Vale? Tercer nivel 00:51:37

Igualmente no se mueve la bola 00:51:38

Sino que se mueve la tabla 00:51:41

Con la diferencia, que en realidad es hasta más fácil yo creo 00:51:42

De que hay unos límites aquí 00:51:45

Contra el que choca la bola 00:51:46

Y yo puedo, lo estoy exagerando un montón 00:51:48

Demasiado 00:51:50

Se queda ahí hasta que va haciendo un límite 00:51:51

Como el juego este que hay 00:51:54

Las pompas, creo que eran los pomperos 00:51:55

Que siempre arriba hay como una especie de 00:51:58

Laberintillo 00:52:00

bueno, pues lo mismo 00:52:01

hasta que llega aquí 00:52:04

bueno, hasta que, y lo voy a hacer 00:52:05

que también sed conscientes 00:52:14

de que siempre cuando estás en un play 00:52:16

puedes coger un elemento 00:52:18

y hacer trampa, ¿vale? porque aquí eres 00:52:20

Dios 00:52:22

ahí, ¿no? 00:52:23

es editable, ¿vale? esto siempre para hacer 00:52:26

pruebas, ya lo he hecho alguna vez, lo he preparado 00:52:28

ya para que sea, mover un poco 00:52:30

la tabla y llegar, ¿vale? 00:52:32

Cuando llego aquí, bueno, esto ya no se pide, hay otro cuarto nivel que es lo mismo, solo que es un poco pinball que cuando llega aquí, cuando choca contra uno de los pivotes, pues le da una fuerza a la bola, el velocity se lo aumenta y cuando llega ahí ya se reinicia el juego, ¿vale? 00:52:33

no sé si 00:52:50

menos este de los pivotes 00:52:51

que no está en la tarea 00:52:53

si no corregirme no está 00:52:54

llegamos hasta el 3 00:52:56

vale 00:53:00

hasta aquí más o menos 00:53:01

lo que es el concepto del juego lo teníamos todos claro 00:53:02

leyendo el enunciado 00:53:05

que a veces es verdad que es farragoso 00:53:06

explicarlo en texto 00:53:08

y ya lo comprobáis 00:53:10

si no era un poco lo que 00:53:13

teníais en mente 00:53:15

vale 00:53:16

o sea, aquí ya se empiezan a meter 00:53:18

incluso conceptos 00:53:20

¿el qué? 00:53:21

lo de que haya que usar 00:53:23

dos crucetas distintas 00:53:26

no tienes por qué hacerlo, ¿vale? 00:53:27

yo lo he hecho 00:53:30

es decir, yo 00:53:31

igual que hicimos con lo del girador, ¿os acordáis que pusimos 00:53:34

otro eje para yo definir 00:53:36

qué letras? tú puedes poner horizontal 00:53:38

y vertical y dejar 00:53:40

lo que viene por defecto que es 00:53:42

una, en una 00:53:43

es decir, que solo haya una horizontal 00:53:45

y no haya una horizontal para la bola y otra para el terreno 00:53:47

lo único es que en los scripts 00:53:49

vas a tener que ir 00:53:51

determinando más 00:53:53

qué script le pones al terreno y a la bola 00:53:54

que eso hay que hacerlo igual 00:53:57

pero yo al tener dos ejes 00:53:58

independientes 00:54:00

tengo más claro cuando le pongo el script a la bola 00:54:02

de qué axis le estoy pasando que si no 00:54:05

y ten en cuenta que si este juego 00:54:07

se complicara más y hubiera otro nivel 00:54:09

en el que sí que de manera independiente 00:54:11

por un lado puedo mover la bola y por otro lado 00:54:13

también la tabla, que podría ser 00:54:15

pues ya lo tienes preparada 00:54:17

¿vale? pero no es obligatorio 00:54:19

tú al final si, cuando le dices 00:54:21

si te das cuenta al final 00:54:23

en el primer nivel, yo en el terreno 00:54:25

tengo aquí preparado 00:54:27

un script que en los siguientes si está activo 00:54:29

¿vale? porque en el primero no me interesa 00:54:31

que se mueva el terreno, solo quiero que se mueva la bola 00:54:33

pero el mismo script lo puedo ir 00:54:35

usando en todos los niveles, entonces 00:54:37

al final cuando yo me meta en este script 00:54:39

lo importante es 00:54:41

este es el que tengo yo preparado para que funcione 00:54:42

al final lo que le estoy diciendo es 00:54:47

que en este el terreno se va a mover según el horizontal terreno 00:54:50

si tú usas solo horizontal y vas discriminando en qué momento 00:54:54

se activa y en qué no, pues también lo puedes hacer, pero así puedo hacer muy fácilmente 00:54:59

o bastante fácilmente, tener los scripts 00:55:03

sabiendo en todo momento qué eje es, tenerlos independientes 00:55:06

por esto que te he dicho, de tenerlo preparado para más adelante 00:55:10

pero si ya es 00:55:12

un poco como lo configures, ¿vale? 00:55:14

es decir, que no tiene por qué hacerse, de todos modos 00:55:16

en las instrucciones 00:55:18

sí que ponía algo 00:55:19

sí, sí, creo que sí que lo pone 00:55:21

pero bueno, esto es lo de siempre, que bueno, yo aquí tengo tantas cosas 00:55:23

que entiendo que 00:55:26

se me había olvidado y lo hice todo con la misma 00:55:27

da igual, si funciona el juego da igual 00:55:30

es decir, ya está 00:55:32

eso sí, ahí estás discriminando 00:55:33

que si usas el mismo script 00:55:35

para mover todo con los mismos ejes 00:55:38

pues que en unos niveles 00:55:40

con la misma cruceta 00:55:44

solo vas a poder mover una u otra 00:55:46

porque el argot no se puede mover 00:55:47

vale, entonces 00:55:49

pues ya está, si lo tienes en cuenta y es lo que busca 00:55:50

pues listo, vale 00:55:53

entonces 00:55:55

no sé si empezamos 00:55:58

o miramos alguna duda concreta 00:56:01

porque empezar tardo bastante 00:56:03

colocando todo, que está bien porque vamos viendo 00:56:05

cosas también, pero lo que me digáis 00:56:07

que no sé si los cinco que estáis aquí 00:56:09

ya os habéis puesto a hacerlo 00:56:12

y más o menos os habéis peleado con el comienzo 00:56:14

o preferís que empecemos 00:56:16

esto ya a petición vuestra 00:56:18

aunque uno me diga 00:56:20

empezamos del principio, empezamos del principio 00:56:25

yo lo estoy mirando pero todavía no he empezado 00:56:26

vale 00:56:31

vamos a intentar hacer el primero 00:56:33

el primer nivel que es el más simple 00:56:36

y el resto en realidad ya es 00:56:39

casi muy parecido 00:56:41

no tiene mucha historia 00:56:43

bueno, sí tiene historia, pero vaya que 00:56:45

entonces, para no mezclar 00:56:47

lo que ya tenía hecho con lo nuevo 00:56:49

voy a crear un nuevo folder, ¿vale? 00:56:50

dudas que me vayan 00:56:53

surgiendo, me las decís, ¿vale? 00:56:54

entonces, tutoría, escenas 00:56:57

y voy a hacer una nueva escena 00:56:59

vacita 00:57:01

las escenas 00:57:02

pensar en ellas como niveles, ¿vale? 00:57:04

las tenemos aquí 00:57:08

y esta va a ser 00:57:09

Devel 1 00:57:10

Tutoría, ¿vale? 00:57:11

Es la que quiero editar 00:57:13

¿Vale? Tenemos una 00:57:16

Escena virgen, aquí esperando 00:57:18

Grandes cosas 00:57:20

De momento voy a estar editando 00:57:21

La escena, vale 00:57:23

Lo primero que tenemos que hacer 00:57:26

Ir armando el nivel, ¿no? 00:57:28

Os pasaba en la 00:57:33

En la 00:57:34

En la 00:57:35

En el aula virtual 00:57:35

Algunas 00:57:39

geometrías, el terreno 1 para el nivel 1 00:57:40

y en el resto ya se puede usar este que es más grande 00:57:43

el terreno 2, luego si vamos 00:57:46

pasando niveles, pues en el último hay que poner ese laberinto 00:57:49

con un poco lo que hemos hecho antes 00:57:52

con la pared que he puesto de límite en el avión 00:57:54

hay que ir montando 00:57:57

todo el armazón del laberinto, pero la base sería 00:57:59

este suelo cuadrado 00:58:04

a ver si se está grabando esto bien 00:58:06

da miedo, vale, perfecto 00:58:08

entonces 00:58:11

para el primer 00:58:13

terreno que tenemos, si nos metemos a ver 00:58:14

qué es cada cosa 00:58:17

aquí vamos a ver que hay 00:58:18

un terreno 00:58:20

lo he abierto con doble clic que abre el visor 00:58:22

3D que tiene Windows 00:58:25

pero nos permite ver cosas 00:58:26

entre otras cosas nos permite 00:58:29

ver 00:58:31

el 00:58:31

la 00:58:34

the white frame 00:58:35

¿vale? si veis este que se llama 00:58:38

terreno 1 maya, tiene una geometría 00:58:40

compleja dentro de que bueno 00:58:42

que no deja de ser prisma 00:58:43

pero es verdad que aquí ya tiene ese agujerito 00:58:45

que si 00:58:48

que si no le definimos 00:58:49

que es ese agujerito, el unity 00:58:52

va a interpretar que ahí no hay agujerito 00:58:54

y ahora lo vemos 00:58:55

y luego por otro lado, para ya no tener que volver 00:58:57

a esto, he dejado otra geometría que es 00:59:00

este collider, que aparentemente es lo mismo 00:59:01

pero vais a ver que 00:59:04

a diferencia del primero es una versión 00:59:05

simplificada 00:59:07

veis que tiene bastante menos geometría 00:59:08

¿vale? ¿y por qué hay dos veces 00:59:11

el mismo? pues porque uno 00:59:13

es digamos la malla bien hecha 00:59:15

el anterior el que tenía 00:59:17

bien digamos distribuido 00:59:18

la malla 00:59:21

¿no? el primero va a servir 00:59:23

para meterle una textura que esté bien 00:59:26

esa textura 00:59:28

de madera etcétera y funcione bien 00:59:30

la otra no tiene por qué funcionar mal 00:59:31

Y esta reducida es para meterla en el Mesh Collider, que como os he dicho antes, es esa forma de detección que es más costosa a nivel de computación, ¿no? Para que detecte. Entonces, la simplificada es una de baja poligonación de la primera, pues ¿para qué? Para ayudar un poquito al ordenador, porque si no, esto es un poco loco. 00:59:34

entonces, dicho esto, pues nada 00:59:55

voy a meter la que quiero que se vea en el juego 00:59:57

la voy a meter a capón aquí 01:00:00

y ahí se ha puesto 01:00:01

cositas que tener en cuenta 01:00:03

ahora mismo 01:00:05

vemos que ahí está el agujero, está todo bien 01:00:06

lo que digo siempre 01:00:10

está apuntando hacia donde queremos 01:00:11

que apunte, miradmos el mismo 01:00:13

en profundidad en Z 01:00:15

y yo quiero que la bola vaya hacia la profundidad 01:00:16

no que venga hacia mí 01:00:20

entonces para empezar, voy a resetear toda la posición 01:00:20

que siempre cuando metemos algo 01:00:23

nos puede luego marear 01:00:25

o perdir 01:00:27

está bien, incluso podría bajarlo 01:00:28

para que, veis este grid 01:00:31

que tenemos aquí, pues para que 01:00:33

para que coincidiera 01:00:35

con el grid, pero 01:00:37

me da un poco igual, porque al final yo la bola luego la voy a situar 01:00:39

lo que no me da igual es eso 01:00:42

que la profundidad del juego 01:00:43

esté orientada al revés, entonces 01:00:45

esto para solucionarlo 01:00:47

básicamente me meto 01:00:48

en el terreno mejor 01:00:51

Pero veréis que el prefab que hay aquí, este cdx, lo podéis desplegar y ver que está compuesto además por, tiene ya como disposición de paquete y tiene dentro el terreno y luego tiene un padre ya hecho, es decir, está metiendo por un lado lo que es la geometría, que sería este terreno 1 dentro de un padre. 01:00:53

ya está configurado así, cuando se exportó 01:01:15

se sacó como que tuviera un padre 01:01:17

que recogiera todo 01:01:19

lo que voy a girar, lo que me interesa girar 01:01:20

ahora mismo es 01:01:23

eje Y, que es el que rota 01:01:24

en este ángulo que queremos corregir 01:01:26

pues que rote 180 grados para que mire 01:01:28

en la otra dirección 01:01:30

en global, ahora mismo 01:01:32

está mirando en la dirección y en local 01:01:34

está al revés, pero tenemos que tener en cuenta 01:01:36

que la profundidad en 01:01:39

el espacio del mundo ahora está bien orientada 01:01:40

hacia donde queremos 01:01:43

eso por un lado, y tenemos esta geometría 01:01:43

y bueno, lo tengo en modo wireframe, pero lo voy a poner para que se vea 01:01:47

con los shaders bien aplicados 01:01:53

¿qué más necesitamos? otra cosa importante 01:01:55

cuando me metemos un FBX 01:02:00

según el programa en el que se haga, puede ser 01:02:05

y esto lo voy a decir incorrecto, pero Maya trabaja en 01:02:09

unidad de metro, blender 01:02:13

en centímetros. Puede que sea al revés, porque 01:02:15

siempre me lío. Eso se comprueba en 01:02:16

el propio software. Entonces, tú puedes hacer 01:02:19

una geometría que aparentemente sea igual, pero 01:02:21

claro, al meterlo en Unity 01:02:23

ya hablamos que cada unidad 01:02:24

era un metro, cada una de estas cuadrículas. 01:02:27

Cuidado, porque a veces podéis haber hecho 01:02:29

un objeto que parece 01:02:31

que la dimensión es 01:02:32

adecuada, y cuando lo metes aquí, pues es 01:02:35

enano. Para eso está esta 01:02:37

conversión de unidades, ¿vale? Para que 01:02:39

cuando se meta el objeto, bueno, 01:02:41

hay que hacer, cuando estamos tocando esta escala, le damos a cualquier parámetro que tengamos aquí, que tiene, ya algo veremos, un montón de conversores y hay que aplicarlo, vais a ver que cuando lo aplico y lo vuelvo a meter, ahora de pronto veis que es enanito, cuidado que esto os puede pasar, y esto es independientemente de la escena, 01:02:43

Quiero decir, que a diferencia de lo que he hecho de darle la vuelta a 180, es enanito, porque la geometría en sí que he importado, le he dicho que lo lea como centímetros, es decir, que si algo tiene como una centésima parte de pequeño o de grande, mirad la geometría porque igual la está interpretando mal el Unity. 01:03:05

entonces volvemos aquí 01:03:29

el hijo le he dado la vuelta 01:03:31

para que mire hacia donde queremos 01:03:33

tenemos aquí esto y nos falta el otro 01:03:34

protagonista de este juego que sería una bola 01:03:37

la bola no pasaba ninguna 01:03:39

geometría porque la creamos nosotros 01:03:41

como una 01:03:43

como una primitiva 01:03:44

espera 01:03:46

pongo aquí en el centro y lo primero que necesitamos 01:03:48

porque si no el juego 01:03:51

sería muy complicado es 01:03:53

que sea de una proporción 01:03:54

adecuada, aquí a diferencia del FB 01:03:56

que hemos metido, que viene de otro programa 01:03:59

ya con las dimensiones que se supone 01:04:00

aquí sin problema 01:04:02

bueno, aquí también podemos hacerlo 01:04:03

vamos a meternos y cambiar la escala 01:04:05

no sería lo suyo porque deberíamos modelar 01:04:08

ya un poco teniendo en cuenta las dimensiones que queremos 01:04:10

pero una primitiva 01:04:12

sale 01:04:14

un metro por un metro porque es lo que 01:04:16

da por defecto 01:04:18

entonces, pues para que entre por este agujero 01:04:20

vamos a decirle que sea un 25% 01:04:23

a ver, todos los ejes 01:04:25

25, 25, 25 01:04:26

a ver, ¿esta bola entra por el agujero? yo creo que sí 01:04:28

sí, sí entra 01:04:32

un poco justa, va a dificultar el juego 01:04:36

pero bueno, vale, y a diferencia de lo que hacíamos 01:04:40

con las instancias, como no va a haber varias bolas y solo quiero una 01:04:44

ese es el juego que yo estoy montando, pues la podemos dejar aquí en la escena 01:04:47

bien centradita, pongo un poco arriba 01:04:51

para que salga arriba, digamos, y en Z 01:04:56

pues para colar 01:04:58

vale, ahora va a empezar el juego 01:04:59

y va a estar ahí 01:05:03

preparadico, le doy al play y no pasa nada 01:05:06

le doy al play y ahora mismo el juego es 01:05:08

pues una bola esperando 01:05:11

algo, ¿no? vale, dado que ya 01:05:14

además habéis empezado a tocar 01:05:16

¿qué falta aquí? 01:05:18

¿qué hay que hacer? 01:05:20

para que, oye, pues esto tenga un poco de vida 01:05:22

el juego 01:05:24

es que no es simplemente que 01:05:24

aunque toque las teclas no pasa nada 01:05:27

sino que directamente no 01:05:29

nada aquí 01:05:30

añadirle 01:05:33

un rigid body ¿no? 01:05:35

¿a quién habría que añadírselo? 01:05:37

a la pelota 01:05:39

vale, le voy a llamar pelota 01:05:40

y a esta pelota le añado 01:05:43

un rigid body para que se vea afectada 01:05:45

por las fuerzas de la física ¿no? 01:05:47

un poco la gracia 01:05:50

además 01:05:51

queremos que la gravedad le afecte 01:05:52

es lo que hemos dicho 01:05:55

en el ejemplo del avión anterior 01:05:56

igual 01:05:58

queremos desmarcar esto, porque a menos 01:06:00

que estemos compensándolo por código todo el rato 01:06:03

si le ponemos la gravedad el avión estaría 01:06:04

o con otras fuerzas, es como 01:06:06

lo que me preguntó 01:06:09

el otro día Gonzalo de un avión 01:06:11

no me quiero meter porque es complicado 01:06:12

al final si le decimos 01:06:15

que algo le afecte la gravedad 01:06:17

la tendencia es que va para abajo, y ahora mismo queremos 01:06:19

pues como nos está pasando a todos ahora mismo 01:06:21

que una fuerza nos esté empujando hacia el suelo 01:06:23

y sea el suelo el que nos detenga 01:06:25

le meto eso, a ver 01:06:26

ya tenemos 01:06:28

se cae, ¿por qué se cae? 01:06:30

es decir, ¿por qué no está 01:06:36

deteniéndole el terreno? 01:06:37

esta esfera tiene una dinámica 01:06:41

tiene su collider, es decir 01:06:42

además es del tamaño, como lo hemos hecho nativo 01:06:44

por defecto está cogiendo muy bien esta geometría 01:06:47

en el wireframe veis que 01:06:49

ahí lo verde, ahí está 01:06:51

¿qué es lo que está pasando? 01:06:53

a ver si alguien me puede decir porque cuando 01:06:55

activo el juego no hay 01:06:57

ningún tipo de interacción entre los dos elementos 01:06:59

no sé si voy 01:07:02

muy rápido o muy lento 01:07:05

si esto es como muy básico si habéis leído el tema 01:07:06

pero bueno 01:07:09

¿qué es lo que pasa? ¿qué es lo que está pasando? 01:07:10

que el plano no tiene 01:07:18

el color item 01:07:20

no tiene collider, ¿no? 01:07:23

es decir, no hay nada que esté diciendo 01:07:26

eh, cuando llega aquí, choca conmigo 01:07:28

¿no? ¿sí? 01:07:30

no hay ningún límite, entonces 01:07:32

solución que podríamos tener, pues 01:07:34

un box collider, ¿no? como 01:07:36

lo hemos hecho, vemos 01:07:37

si os fijáis, que lo ha cogido 01:07:40

de tal forma, que muy bien le ha puesto 01:07:42

los límites ya, a ver, le voy a 01:07:44

dar al box collider 01:07:46

y placa, ahí se queda la bola 01:07:47

¿vale? ya estamos 01:07:50

jugando 01:07:52

en la liga de las físicas 01:07:53

esto va a entrañar un problema 01:07:56

porque claro, si os fijáis aquí hay un agujero 01:07:58

y el box collider 01:08:00

está tapando ese agujero 01:08:02

no hay nada que le diga no 01:08:04

esto no es suelo también 01:08:05

esto es un agujerillo, por eso tenemos que usar 01:08:08

el mesh collider, también lo hemos llevado ahí 01:08:10

pero ya os doy 01:08:12

un primer problema, de momento lo dejo 01:08:14

como 01:08:16

método chapucero pero 01:08:16

esto no va a ir del todo bien 01:08:19

¿qué habrá que hacer con la pelota? 01:08:22

pues decirle que vaya para adelante o para 01:08:24

atrás, ¿no? 01:08:26

entonces, ya nos tenemos que meter a 01:08:28

hacerle un 01:08:30

tip 01:08:32

a esta pelota, que como tiene un rigid body 01:08:33

¿vale? le podemos 01:08:36

aceptar a esas velocidades, a esas fuerzas 01:08:38

le podemos decir, oye, avanza 01:08:40

añádame una fuerza y le voy para un lado 01:08:41

o para otro 01:08:44

importante también, que esto está en el tema 01:08:44

Ahora, los objetos, si entramos en el mundo de la física, tienen que tener un peso, también tienen una resistencia al aire, tanto en posición como en rotación, y esto no sé si lo habéis visto, pero si vais al espacio, en realidad lo que hace que un objeto en la luna baje más o menos rápido no es su peso, no es la que sería su masa, sino la resistencia que tiene el aire. 01:08:48

no sé si lo habéis visto, pero 01:09:13

si cogéis una hoja de papel 01:09:16

un folio 01:09:18

que pesa, yo que sé, 15 gramos 01:09:19

no lo sé, y lo tiras 01:09:23

como folio, vais a ver que baja mucho 01:09:24

más despacio, que si esa misma pelota 01:09:27

que seguirá pesando 15 gramos 01:09:28

la 01:09:30

hacéis una bola y la tiráis 01:09:32

¿y por qué es eso? porque el cuerpo cuando 01:09:34

está plano, tiene una resistencia al aire 01:09:37

bastante diferente a cuando es una pelota, y pesa lo mismo 01:09:38

es decir, la masa es la misma 01:09:41

Lo que sí va a afectar a la masa es cuando aplicamos fuerzas, añadimos una fuerza, pues si estamos empujando una caja de 500 kilos, si hay gravedad y si hay fuerzas como las de la Tierra, pues va a costar mucho más mover un cuerpo de 500 kilos que de un kilo, como sería este caso. 01:09:42

la velocidad de cómo se mueven las cosas 01:10:00

en sí está en la resistencia 01:10:05

pero la velocidad del empuje 01:10:07

la fuerza del empuje dependerá de la masa 01:10:09

un poco hablando de 01:10:11

en la tierra, porque donde no hay gravedad 01:10:13

los objetos de 01:10:15

un elefante también se podría 01:10:16

empujar y se movería rápido 01:10:19

no hay más inercia 01:10:20

ni fuerzas 01:10:22

no sé hasta aquí qué tal 01:10:24

bien, esto también 01:10:27

Yo me tiro el pisto porque yo soy experto en gravedades y en física aplicada, pero bueno, al menos. 01:10:31

Sí, ¿no? ¿Hasta aquí bien? 01:10:38

Vale, entonces, pues lo que vamos a hacer es ya generar un script para nuestra pelota, ¿no? 01:10:40

La vamos a mover. 01:10:46

Necesitaremos decirle con qué teclas y a qué afecta. 01:10:48

Vamos a llamarlo pelota... 01:10:53

Control, lo que sea, ¿vale? 01:10:57

ahí se está creando 01:11:01

y 01:11:02

se le aplico 01:11:03

lo importante, se le aplico como componente 01:11:06

a la pelota 01:11:08

se va aplicando ahí 01:11:09

un segundito que me traigo aquí 01:11:12

ahí lo tengo 01:11:14

y yo me voy a poner 01:11:17

que viene bien 01:11:19

porque si no 01:11:21

vamos a ver 01:11:22

player manager 01:11:27

Un segundo, eh, perdón. Ah, vale, que aquí tengo el... Vale, que tengo preparadas mis cosas. Vale, vamos a ello. 01:11:41

como estamos en la pelota 01:12:27

y aquí es otra cosa de código que hay que tener en cuenta 01:12:31

lo que vamos a hacer 01:12:34

y lo mismo que pasaba 01:12:36

en el anterior ejercicio 01:12:39

primero lo suyo es casi 01:12:44

coger una hoja y escribir lo que queremos conseguir 01:12:46

para luego ya interpretar la código 01:12:49

y si nos ponemos a pensar lo que queremos es 01:12:51

Ahora también las limitaciones del enunciado de la tarea. Queremos afectar, añadir fuerzas a este RigidBody, ya no queremos afectar al Transform, como he dicho hasta ahora. Queremos afectar, añadir fuerzas a un cuerpo físico, al RigidBody. 01:12:54

entonces ya a diferencia de lo que hacíamos antes 01:13:10

ya no vamos a estar afectando al componente 01:13:14

a la clase transform, ahora queremos afectar a la clase rigid body 01:13:18

cada componente digamos, cada componente que tenemos 01:13:22

tiene una clase asociada, no sé si os acordáis cuando hacíamos lo de 01:13:25

las instancias, que poníamos como clase aquí al principio 01:13:30

decíamos aquí antes del start, etcétera, cuando declaramos 01:13:34

hacíamos la clase transform 01:13:38

de la nave, entonces cogía 01:13:41

arrastramos aquí por un serialize 01:13:43

field 01:13:45

un serialize field 01:13:45

que sale en el 01:13:49

editor y está esperando 01:13:51

que movamos 01:13:54

un objeto para referenciar 01:13:55

en todo momento el transform de ese objeto 01:13:58

que es el de sí mismo, en este caso 01:14:00

ahora lo que queremos hacer es 01:14:02

afectar mediante código 01:14:04

no a un transform, sino 01:14:06

a lo que esté dentro de, y vais a ver que si empiezo a escribir RigidBody 01:14:08

vais a ver que está también el RigidBody 2D 01:14:12

cuando vamos en 2D, que es otro tipo de dinámicas 01:14:14

parecidas, pero que solo funcionan en dos ejes, ¿vale? 01:14:18

Yo tengo aquí el RigidBody, ¿vale? Y cuando yo guardo 01:14:20

y ahora arrastro, a diferencia del iconito ahí 01:14:24

cambiar en breves, ahí tiene el iconito 01:14:27

del transform, que es este 01:14:30

y ahora cuando yo arrastre la pelota aquí 01:14:33

lo que va a coger es 01:14:36

el RigidBody, veis que lo que está haciendo 01:14:37

es coger, referenciar 01:14:39

a un componente que está dentro 01:14:42

de este objeto 01:14:43

ahora mismo, si yo 01:14:45

y te digo esto, le voy a llamar 01:14:47

esto se suele poner mucho RB 01:14:49

de RigidBody y pelota 01:14:51

en nombre de componente 01:14:53

RB sirve mucho para ver 01:14:55

cuando usemos esto después 01:14:57

va a ser un RigidBody, yo ahora mismo 01:14:59

si en el update, y voy a saltarme 01:15:01

un par de pasos, ahora vuelvo para atrás 01:15:04

Ahora yo cuando me meto en RbPelota, yo lo que puedo hacer es decirle, vale, pues estoy accediendo al componente RigidBody de este objeto porque se ha pasado desde el inspector y ahora ya puedo acceder a los distintos parámetros del componente RigidBody de esta clase que tiene. 01:15:05

entonces, si os fijáis 01:15:27

para que vayáis también viendo la dinámica 01:15:29

de cómo funciona, recordad que con el punto 01:15:31

te vas metiendo en sus niveles 01:15:33

y vais a ver que hay cosas como, si voy por ejemplo 01:15:34

a la M, que esto va por 01:15:37

alfabético 01:15:39

tenemos la masa, a ver 01:15:40

la masa, vale 01:15:42

yo aquí, si ahora mismo le digo 01:15:44

no, yo quiero que la masa sea de 50 01:15:47

de 50, vale 01:15:49

estoy accediendo al componente 01:15:51

de este objeto que le he pasado por serie a Life Fill 01:15:53

y que valga 50, entonces esto significa 01:15:55

que cuando arranque el juego 01:15:58

porque está en el start, cuando arranque el juego 01:16:01

una vez, ah bueno, me lo he puesto en el date 01:16:03

me lo pongo en el start, da igual 01:16:05

una vez, según empiece el juego 01:16:06

vais a ver que cambia este parámetro 01:16:09

directamente 01:16:10

es decir, bueno, cuando arranque el juego esto va a pesar 01:16:11

50 kilos 01:16:15

vale, por lo que sea 01:16:16

ha reseteado cuando cambia el nombre 01:16:22

vuelvo a pasarle el RigidBody 01:16:24

y ahora sí que sí 01:16:27

no voy a hacer 01:16:28

vale, luego a la masa 01:16:30

cuenta 01:16:32

a ver, ahora 01:16:34

quería hacerme caso 01:16:36

vale, veis, ahora ha bajado muchísimo más rápido 01:16:37

porque 01:16:41

pasa de 50 kilos 01:16:42

porque tiene 01:16:44

además muy poca resistencia al aire 01:16:47

y me la ha definido 01:16:48

como 50 kilos, vale, yo ya 01:16:51

tengo acceso al drag, por ejemplo 01:16:52

pues el drag ahora es uno de los 01:16:55

parámetros 01:16:56

angular drag 01:16:58

veis que están todos 01:17:01

para referenciar por código 01:17:02

a los distintos, que con esto es con lo que podemos hacer 01:17:04

editable, que cuando suceda tal cosa, oye pues 01:17:07

me meto en la masa del 01:17:09

rigbody y entonces de pronto el objeto 01:17:11

empieza a pesar 01:17:13

2000 kilos, pues en cierto momento 01:17:14

si yo en una condicional, igual que hemos hecho ahora 01:17:16

de pronto le digo, y cuando se cumpla 01:17:19

condición, pues esto 01:17:21

pasará, bueno, aquí he puesto una tilde, cosa 01:17:24

prohibidísima, ¿vale? y esta 01:17:26

variable no existe, pero para que veáis el ejemplo 01:17:28

cuando se cumpla esta condición 01:17:30

pues la pelota pasa a pesar 50 01:17:31

a lo mejor en Super Mario, pues cuando 01:17:34

te toman la seta que te hace crecer 01:17:36

de pronto queremos que las físicas 01:17:38

pues de la masa, pues de pronto 01:17:40

sea como si pesara el triple, pues con 01:17:42

este tipo de cosas ya podríamos 01:17:44

ir modificando, que luego 01:17:46

al pasar el tiempo 01:17:48

a usar con rutinas o lo que sea 01:17:49

pierde el efecto de la 01:17:52

de la seta, pues habrá otra condición 01:17:53

de si se pierde el efecto de la seta 01:17:56

porque la buleana ya le dice que 01:17:58

cambia de estado 01:18:00

pues condición 01:18:01

otra, si se cumple 01:18:03

pues entonces el Super Mario pesará 01:18:05

otra vez lo que pesaba 01:18:07

que son 20 kilos 01:18:10

tampoco es cualido el nombre pero pues eso 01:18:11

¿vale? es un poco la lógica 01:18:14

que ya podemos ir accediendo a distintos 01:18:15

componentes, si vamos pensando 01:18:17

que es cada clase, está la clase transform 01:18:20

está la clase rigidbody 01:18:21

a ver, ahora vuelvo a la rigidbody 01:18:23

porque es la que nos ocupa, pero incluso 01:18:26

mesh 01:18:28

renderer, vale, otro 01:18:30

componente que tenemos ahí, que con una 01:18:31

geometría está, este no es exactamente 01:18:34

mesh renderer, pero si ponéis mesh 01:18:35

vais a ver 01:18:38

que hay uno que es mesh que ocupa 01:18:39

más cosas y luego hay uno que es mesh renderer 01:18:41

y si ahora mismo rb 01:18:43

pelota, que es como llamado al acceso 01:18:45

a esa clase, que habrá que 01:18:47

asignar 01:18:49

el vector, si yo me meto en 01:18:51

rb pelota 01:18:53

ahora al dar al punto ya no me va a salir lo de 01:18:55

masa, ni lo de 01:18:57

drag, porque eso 01:18:59

era de la clase 01:19:01

rigidbody, ahora me podré meter en 01:19:03

cosas como 01:19:05

yo que sé, 01:19:06

dynamic occlusion, a ver si sale 01:19:08

dynamic occlusion, bueno permitir 01:19:11

occlusion cuando dinámica, que está relacionado 01:19:13

con eso, o 01:19:15

material, ¿vale? Pues el material lo podremos cambiar accediendo, ¿vale? Accediendo a estos 01:19:17

parámetros, ¿vale? Veis entonces que cada componente suele tener una clase. BoxCollider, 01:19:24

por ejemplo, también es otro componente. Entonces normalmente, bueno, aquí sería 01:19:29

sphereCollider. Ahora mismo no, este no lo encontraría porque no existe ninguno, excepto 01:19:35

si le pasáramos el objeto pelota, pero sphereCollider habría que otra vez, y fijaos de nuevo en 01:19:40

como el iconito va a cambiar con respecto al del RigidBody, meto la pelota y veis, 01:19:46

¿verdad? Que voy rápido, le guardo y ahora mismo el RB pelota en realidad es de la clase 01:19:51

SphereCollider, ¿no? Entonces aquí, ahora cuando le meta la pelota, lo que está buscando 01:19:58

es SphereCollider, en este caso, voy a quitar esto, porque puede que directamente no me 01:20:04

claro, sí, aquí debería 01:20:15

haber, ahí, ahora, ahora cuando 01:20:22

meta la pelota en 01:20:24

tip 01:20:25

está demandando, veis que 01:20:27

el iconito ya no es el del real body, es el del 01:20:30

sphere collider, porque estamos 01:20:32

hablando de el componente 01:20:33

de la clase asociada a ese componente, esto es muy 01:20:35

importante, porque si 01:20:37

entendemos esto, ya empezamos a ver 01:20:39

la luz con, puedo cambiar 01:20:41

por código, y sabiendo ahora además 01:20:43

condicionales y esto de las booleanas 01:20:45

de una forma todavía 01:20:47

bueno, pues inicial 01:20:48

ya podemos ir cambiando 01:20:52

el color del material cuando pase 01:20:54

por tal sitio, por poner un trigger 01:20:55

cuando pase por aquí que se cumpla 01:20:58

tal condición, entonces ya podemos ir 01:21:00

empezando a 01:21:02

vislumbrar 01:21:04

ciertas cosas 01:21:06

¿qué tal? hasta aquí 01:21:07

esto creo que es bastante importante 01:21:09

¿qué tal? 01:21:13

bien 01:21:16

¿esto lo habéis intuido 01:21:16

ya o... 01:21:19

No, entiendo que no, ¿eh? 01:21:21

Porque muchas veces te puedes escribir RigidBody 01:21:23

porque te lo dice no sé quién y no sabes por qué es. 01:21:25

Es que los componentes tienen 01:21:28

una clase, normalmente, casi todos. 01:21:29

Una clase concreta 01:21:32

con los métodos de esa clase, 01:21:33

los parámetros. ¿Vale? 01:21:35

¿Bien? ¿Sigo? 01:21:37

Sí. 01:21:40

Y, evidentemente, dependiendo de a qué clase 01:21:41

estemos metiéndonos, 01:21:43

tendrá unos parámetros u otros que son los mismos. 01:21:45

Los mismos y más de los que 01:21:47

estamos viendo en el inspector. Entonces, ahora mismo lo que nos interesa es afectar al rigid 01:21:49

body para aplicar fuerzas cuerpo físico. Importante, cuando cambiemos el nombre o cambiamos 01:21:55

el tipo de clase, cuidado, eso a veces es mejor no usar el public o el serialized field, cuidado 01:22:02

porque en el inspector de pronto hay que volver a reenganchar. Hace referencia, como ha cambiado 01:22:10

el tipo y dice yo no encuentro eso 01:22:18

y ya te fastidia un poco 01:22:19

y es por eso por lo que voy a explicar lo siguiente 01:22:21

ahora mismo 01:22:24

y esto también es 01:22:25

no es complicado hasta que lo pillen 01:22:28

ahora mismo lo que estamos haciendo 01:22:30

es siempre o muy habitualmente 01:22:32

decirle a que nos 01:22:34

estamos refiriendo del código 01:22:36

cogiendo un GameObject y 01:22:38

arrastrándoselo, lo hemos hecho en la instancia 01:22:40

en las instancias de los 01:22:42

obstáculos también, lo hemos hecho en varias ocasiones 01:22:44

el problema está 01:22:46

en que claro, primero el fastidio este 01:22:48

de que se te puede reenganchar y tienes que ir revisando 01:22:50

todos los objetos y has cambiado alguna cosa 01:22:51

de, ah pues aquí hay un hueco que no 01:22:53

tengo que arrastrar, hay una forma 01:22:55

en vez de decirle 01:22:57

tanto en public como con serialize fill 01:22:58

que es, hazme llegar 01:23:01

este rigidbody a través del inspector 01:23:03

haz el objeto 01:23:05

y si tiene un componente rigidbody pues 01:23:07

cojo, chupo lo que tenga ese 01:23:09

rigidbody, pero si yo lo tengo esto en private 01:23:11

que no 01:23:13

vamos, recordad que private o no 01:23:14

poner nada es lo mismo ¿vale? porque por defecto 01:23:17

las variables son privadas 01:23:19

al final aquí 01:23:20

no tengo forma de decirle 01:23:22

a qué rigidbody 01:23:25

le voy a afectar ¿no? 01:23:27

yo tengo aquí una variable rigidbody 01:23:29

aquí en este momento hay que 01:23:30

conocer el método 01:23:33

getComponent, de hecho os dije 01:23:35

en su momento, es importante la palabra componente 01:23:37

para entender esto, podemos 01:23:39

por código hacer que el código busque 01:23:41

un elemento 01:23:43

o un componente o una propiedad 01:23:45

de un 01:23:47

GameObject sin 01:23:48

tener que decirle explícitamente 01:23:50

en el inspector que GameObject es 01:23:53

entonces para decirle 01:23:54

oye yo lo que voy a hacer 01:23:57

para modificar 01:23:58

la velocidad, la fuerza de este RigidBody 01:24:00

pues aquí tengo una variable 01:24:03

llamada RigidBody pelota pero 01:24:05

realmente nadie, no estamos diciendo 01:24:07

en ningún momento 01:24:09

a qué objeto se refiere 01:24:10

porque no es que asuma 01:24:12

por defecto, ah pues si en esta clase 01:24:15

le meto, como está en el objeto 01:24:17

de la pelota, si le meto 01:24:20

una variable RigidBody 01:24:21

asume que es de sí misma, no, igual que cuando 01:24:23

hemos puesto el serializeField ha habido que arrastrar la pelota 01:24:25

a sí misma, aquí por código 01:24:27

podemos decirle, yo quiero 01:24:29

que tú busques 01:24:31

un componente en este 01:24:33

en este objeto, vale, si no 01:24:35

pongo delante ningún otro objeto 01:24:37

como hacíamos con lo de, os acordáis 01:24:39

con transform que si poníamos delante el nombre 01:24:41

de otra variable, buscaban el transform 01:24:43

del objeto que le habíamos remitido 01:24:45

me estoy liando 01:24:47

un poco, vale 01:24:49

si yo le digo, cógeme el componente 01:24:50

llamado RigidBody 01:24:53

de este objeto 01:24:55

vale, le dan una orden 01:24:57

que es, como en la 01:24:59

sintaxis, está la función 01:25:01

y sabemos que es función porque tiene 01:25:03

este paréntesis, que tiene todas las funciones 01:25:05

como la date, pero tiene esta añadida 01:25:07

entre 01:25:09

no sé si esto se llaman llaves 01:25:10

entre mayores y menores 01:25:13

en donde hay que decirle, cógeme el componente 01:25:14

llamado tal de este objeto 01:25:16

¿vale? 01:25:18

y ahora sí que está entendiendo 01:25:20

el código que tenemos que afectar al rigidbody 01:25:23

de la pelota, porque está 01:25:25

cogiendo el rigidbody de sí mismo 01:25:27

del objeto que tenga el script 01:25:28

que eso no quita 01:25:31

que en cierto momento podamos 01:25:33

decirle 01:25:35

por ejemplo 01:25:35

¿vale? y esto, bueno, se puede 01:25:38

complicar bastante más, pero voy a hacerlo 01:25:41

Lo más simple que se me ocurre. 01:25:42

Si yo pongo un serialize field. 01:25:44

Del terreno. 01:25:47

El rigidbody. 01:25:50

Del terreno. 01:25:52

Voy a llamar. 01:25:55

Rigidbody terreno. 01:25:56

Yo puedo decirle. 01:25:58

No. 01:26:01

Game. 01:26:03

Quiero que coja todo lo que tiene que ver con el game. 01:26:03

Vale. 01:26:06

Aquí he vuelto a poner el serialize field. 01:26:07

Porque si no tendría que explicar otro método más. 01:26:09

Pero yo puedo decirle que esta variable que se ocupa de RigidBodies, en vez de coger el RigidBodies de sí mismo, el componente de sí mismo, que coja el de el objeto RBTerreno, que ahora mismo está cogiendo el componente, el RigidBodies, del GameObject que le haya pasado por el inspector. 01:26:11

otra vez estamos recurriendo al inspector 01:26:36

cada vez podemos ir quitando más 01:26:38

serialize fill, si vamos 01:26:40

poniendo más métodos, pero bueno, voy al 01:26:42

más simple, ¿no? Yo puedo 01:26:44

decirle, cógeme el componente RigidBody 01:26:46

que ahora mismo es una chorrada de un piano porque 01:26:47

no hay ningún RigidBody, todavía no se lo he puesto 01:26:49

¿vale? No hay ningún RigidBody, entonces 01:26:51

no encontraría y daría problemas, pero si 01:26:53

yo le 01:26:56

le pongo aquí un RigidBody 01:26:56

simplemente por la prueba, aunque va a haber que ponérselo 01:26:59

por distintas cosas, claro, yo a lo mejor 01:27:01

desde el script de la pelota 01:27:03

cuando haga algo con la pelota 01:27:05

quiero afectar a los parámetros del RigidBody 01:27:07

del terreno 01:27:09

entonces yo le digo, vale, pues de este 01:27:10

objeto terreno, que es el paso aquí 01:27:13

de hecho de este objeto que hay aquí 01:27:15

vale 01:27:17

esta variable de RigidBody 01:27:18

que gestiona los compartimientos 01:27:21

de RigidBodies, que me coja 01:27:22

el RigidBody, pero no 01:27:25

de sí mismo, sino del terreno 01:27:27

vale, entonces yo ahora 01:27:29

mismo con RB pelota, en realidad 01:27:31

si me meto a cambiar la masa 01:27:33

y le digo 50, como hemos hecho antes, ¿vale? Lo estamos haciendo sin tener que, es decir, 01:27:35

el RigidBody en ningún momento lo estamos referenciando por inspector, lo estamos cogiendo 01:27:44

por código. Entonces, vais a ver que cuando ahora yo le dé al play, tened en cuenta que 01:27:47

tanto la pelota como el terreno tienen RigidBody, vais a ver que la masa que cambia ahora mismo 01:27:56

no es de sí misma, del RigidBody 01:28:02

de sí mismo, sino el del terreno 01:28:04

vamos a ver 01:28:05

entonces podéis acceder a distintos objetos 01:28:06

bueno, claro, le he puesto un RigidBody 01:28:09

al terreno y le he aceptado la gravedad, no lo he quitado 01:28:12

lo voy a quitar 01:28:14

por ejemplo, aquí no queremos usar gravedad 01:28:15

entonces ya 01:28:18

solo se queda ahí 01:28:18

es verdad que se ve afectado por las fuerzas físicas 01:28:22

lo que me importa, cuando se ha dado 01:28:24

al play, la pelota sigue teniendo la masa 01:28:26

de 1, porque nada se lo ha cambiado 01:28:28

pero la del terreno, veis que ha pasado a tener 01:28:29

50. Importante, podéis acceder a los componentes de otros objetos a través de código, sin 01:28:32

tener que usar el inspector para nada. Y es más, eso, ahora mismo lo estamos serializando, 01:28:41

pero simplemente para que suenen más adelante. También podemos decirle que la RB pelota, 01:28:46

en realidad, y aquí ya no me daría igual, que afecte a un objeto. Esto lo escribo muy 01:28:54

rápido porque tampoco me interesa que 01:29:01

nos pongamos locos, pero si empezamos a 01:29:03

decirle que dentro de 01:29:05

la clase GameObject en general, de los GameObjects 01:29:07

haga, encuéntrame un objeto 01:29:10

que se llame, de los que hay aquí 01:29:11

¿vale? que se llame terreno 1 y lo pongo 01:29:13

literal en un string 01:29:15

terreno 1 ¿vale? y de ese terreno 01:29:16

1 ya sí que métete 01:29:19

y búscame el componente RigidBody y 01:29:21

todo lo que vaya a hacer con RBPelota 01:29:23

se refiere a eso 01:29:25

ahora mismo vais a ver que no 01:29:27

voy a meter absolutamente nada por 01:29:29

inspector, que yo 01:29:31

y lo suyo sería, dado que 01:29:32

a lo que va a afectar es el terreno, aunque esté en el 01:29:35

script aplicado a la pelota 01:29:37

pues lo suyo es que ponga terreno, pero bueno 01:29:39

que esto no deja de ser un nombre 01:29:41

pues si yo pongo aquí rbterreno 01:29:42

rbterreno, vais a 01:29:45

ver que sin referenciar nada en absoluto 01:29:47

en el código 01:29:50

va a hacer otra vez 01:29:51

el cambio de la masa al terreno 01:29:53

desde el script de la pelota 01:29:55

es decir, el terreno no tiene en ningún momento 01:29:56

aplicado el script, es la pelota 01:29:59

y en la pelota, cuando hagamos el play 01:30:01

otra vez, vais a ver que la masa 01:30:04

que cambia no es la de la pelota 01:30:06

la de la masa 01:30:07

y la que va a tener 50 es el terreno 01:30:09

¿vale? 01:30:12

esto es quizá enrevesado 01:30:14

y esta última parte para hacerlo 01:30:16

sin usar 01:30:18

el serialize fill en absoluto 01:30:20

es un poco peleaguda 01:30:21

y voy a poner otra vez pelota 01:30:23

porque es lo que vamos a tocar 01:30:25

pero creo que es 01:30:27

bastante importante ir 01:30:29

haciéndose la cabeza, ¿vale? Otra vez 01:30:31

sin meter nada por 01:30:33

referencia, siendo privado, ahora mismo estoy 01:30:35

cogiendo el componente RigidBody 01:30:38

llamado RigidBody de la pelota 01:30:40

y lo guardo en esta variable para ya poder 01:30:42

hacer lo que quiera con ella. 01:30:44

Hasta aquí, ¿qué tal? 01:30:46

Sé que hablo muy rápido, como le doy vueltas 01:30:47

creo que lo 01:30:50

alivio porque le doy 20 vueltas 01:30:51

pero voy rápido. ¿Qué tal? 01:30:54

A ver si 01:30:59

se entiende. 01:31:00

Esto es pensar 01:31:01

De dónde va una cosa 01:31:02

Y a dónde va la otra 01:31:06

Pero veis que ya se pueden conectar objetos 01:31:07

Incluso con variables privadas 01:31:10

Que no es necesario 01:31:12

Usar el inspector y de hecho es muy recomendable 01:31:13

Porque si por ejemplo 01:31:16

Fuera un objeto que se 01:31:18

Spawnea, que aparece en mitad del juego 01:31:20

Claro, tú puedes 01:31:22

Arrastrar al inspector de Unity 01:31:24

Mientras estás editando el juego 01:31:26

Y luego lo arrancas, pero no puedes en mitad del juego 01:31:28

arrastrar, hay que hacerlo por código 01:31:30

entonces es algo que hay que ir 01:31:32

haciendo la cabeza ahí 01:31:34

¿no? entonces 01:31:35

ahora mismo tenemos 01:31:38

uy, ya es la hora 01:31:39

en breve os voy a cortar y bueno 01:31:41

importante 01:31:44

RigiPod y de momento 01:31:45

voy a quitar 01:31:47

para dejarlo 01:31:50

no he avanzado quizá 01:31:51

ciertas dudas que teníamos pendientes 01:31:54

de lo del agujero 01:31:56

os dejo que sigáis probándolo por vuestra cuenta 01:31:58

y la semana que viene 01:32:00

pongo otra tutoría y seguimos viendo cosas 01:32:02

¿vale? porque es que ya tengo que cerrar 01:32:04

el cuarto me echan 01:32:06

¿vale? 01:32:08

esto además así hasta aquí 01:32:10

creo que he resuelto algunas dudas 01:32:12

o lagunas que pudierais tener 01:32:14

parece la semana que viene hacemos otra 01:32:15

Tutoría 5 - DEIM - UT2y3 - Curso 22·23 - 8Febrero - Contenido educativo

Del mismo autor…

Christma 2025 CPEE María Montessori

Arqueopinto video 11

Arqueopinto video 10

Arqueopinto video 9

Arqueopinto video 8

Arqueopinto video 7

Arqueopinto video 6