Tutoría 6 - DEIM - UT3 - Curso 23·24 - 8 Febrero

venga, empiezo 00:00:00

si quieres, me estás viendo 00:00:03

me lo estás viendo todo, ¿no? 00:00:04

te estoy viendo, sí, tu Unity 00:00:06

vale, me estás viendo tu Unity, bueno, esta primera parte 00:00:08

esta primera parte en principio no ha tenido 00:00:11

ningún problema, le he quitado 00:00:15

el material, pero vamos, que de momento me ha salido 00:00:16

vale, le doy, la cámara me la 00:00:19

enfoca, vale, me va 00:00:21

me desaparece cuando lo metes 00:00:22

no estás viendo, ¿no? 00:00:25

sí, lo único que va flotando, ¿no? 00:00:26

sí, es que está como un poco alto 00:00:28

pero bueno, yo supongo que será por un poco porque 00:00:31

lo tengo que bajar un poco, el Collider 00:00:32

lo tengo que bajar a lo mejor un poco más, ¿no? 00:00:34

y cambia la segunda, lo has visto, ¿no? 00:00:36

el problema está con las plataformas 00:00:39

lo empiezo a tener ya, ¿no? 00:00:41

vale, me refiero que es que 00:00:42

como que son muy bruscos los movimientos 00:00:44

lo ves, ¿no? sí, sí 00:00:46

que da como saltos a veces, vale 00:00:48

y eso que le estoy dando muy poquito, yo entiendo 00:00:50

que puede ser por el... porque a lo mejor 00:00:53

le tengo que poner... 00:00:55

vamos a irlo viendo 00:00:56

lo que hay que ir, claro, cuando me enviaste 00:00:58

el comentario es que solo con el código 00:01:00

no me sirve, porque claro, necesito también 00:01:02

un poco el contexto de en qué lo estás 00:01:04

aplicando. Una cosilla, te sale 00:01:06

un mensaje por ahí de... estás compartiendo 00:01:08

toda su pantalla y hay una opción que no es 00:01:10

dejar de compartir, dale a la otra que es ocultar 00:01:12

dale ahí 00:01:15

a la derecha, ¿no? sí, dale, vale 00:01:16

para que no esté ahí en mitad. Vale, si te parece 00:01:18

vamos a la escena 1 00:01:20

vamos allá 00:01:22

espera, me salgo de aquí 00:01:23

vale, y una cosa también 00:01:26

no sé si tú te das cuenta de que cuando juegas 00:01:28

se ve como pixelado 00:01:30

sí, sí, me ha pasado, sí 00:01:31

vale, vamos a... te voy a decir primero 00:01:34

qué es lo que está ocurriendo 00:01:36

en la pestaña... 00:01:37

vale, sí, sí 00:01:39

no, no, pues haces 00:01:41

haces estupendamente, yo mientras voy a intentar 00:01:44

ponerte 00:01:46

para la grabación 00:01:47

sí, sí, sí 00:01:49

esto es desesperante 00:01:53

a ver, lo de siempre 00:01:54

¿qué es esto? 00:01:56

este módulo son muchas cosas que se van sumando 00:01:56

¿vale? pero poco a poco 00:01:58

quien esté intentando 00:01:59

hacer las tareas, ya os digo que vais a ir asimilándolo 00:02:02

y cuando... 00:02:04

no, si el caso es que la mecánica, a ver, la idea 00:02:05

de los scripts, todo lo que es el lenguaje 00:02:07

lo estoy entendiendo, ¿eh? o sea, más o menos 00:02:10

casi todo lo entiendo, ¿eh? 00:02:11

si ves los videos, si ves lo de los apuntes 00:02:13

si ves todo, pues lo vas entendiendo 00:02:16

lo que pasa es que luego a la hora de ponerlo en práctica 00:02:17

es que hay veces que digo, mira, me vuelvo loco 00:02:19

pero bueno, que a mí también me pasa, ¿eh? 00:02:21

digo que eso es normal 00:02:24

que eso es normal 00:02:25

y luego dices, va, incluso 00:02:26

aunque no lo estés haciendo mal, es una chorrada 00:02:27

y le das vueltas y es una coma 00:02:30

que no has puesto bien, entonces 00:02:32

es peliagudo, pero esto es práctica 00:02:33

en buena parte 00:02:35

hay que practicar porque si no es imposible 00:02:38

vale 00:02:40

cuando 00:02:41

ya estoy, ya estoy 00:02:42

en la pestaña game, ¿vale? donde está 00:02:45

el visor 00:02:48

en el Unity hay una pestaña de escena 00:02:49

que es donde estás trabajando todo el rato 00:02:52

arriba a la izquierda 00:02:53

vale 00:02:55

en game lo que se está viendo es 00:02:56

lo que va a verse cuando des a la reproducción del juego 00:02:58

y aquí se ve pixelado 00:03:00

porque si te fijas 00:03:02

justo encima de donde está la pelota pone scale 00:03:03

y tú la tienes al 2,7 00:03:06

ponlo al 1 00:03:08

por defecto debería estar siempre al 1 00:03:08

¿vale? porque lo que estás haciendo ahora 00:03:13

es un zoom, digamos, sobre la visualización 00:03:15

del juego, pero la cámara realmente 00:03:17

lo que está viendo es esto 00:03:19

tendrás que acercar más la cámara 00:03:20

no sé si la has puesto un offset 00:03:21

imagino que sí 00:03:23

porque si lo que está viendo es el video 00:03:23

lo que haces es un zoom 00:03:26

estás como ampliando esa visibilidad 00:03:27

de la escena 00:03:30

entonces empieza a pixelar 00:03:31

porque es como si coges una foto en Photoshop 00:03:32

y la aumentas 00:03:34

pues que se empieza a pixelar 00:03:35

porque el tamaño que tiene realmente 00:03:36

es este display que estamos viendo ahora 00:03:38

¿vale? 00:03:40

vale 00:03:41

una cosa 00:03:42

pero por ejemplo esto sí 00:03:43

en el caso ya 00:03:44

esto sale del tema 00:03:45

si 00:03:46

por ejemplo en el 00:03:47

con un Photoshop o con una de estas 00:03:48

si tienes una buena resolución 00:03:49

aunque lo acerques 00:03:50

no se pisela, claro 00:03:51

entiendo que es por el programa, ¿no? 00:03:52

claro, es decir 00:03:55

tú ahora mismo 00:03:56

tú 00:03:57

ten en cuenta que lo que hacemos 00:03:58

con un motor de videojuegos 00:03:59

como en Unity 00:04:00

las imágenes no que estén ya procesadas 00:04:01

de antes 00:04:03

si nos acerquemos 00:04:04

que en realidad 00:04:05

me estoy contradiciendo 00:04:06

ahora lo aclaramos 00:04:07

estamos generando la imagen 00:04:08

en tiempo real 00:04:09

¿no? 00:04:10

entonces 00:04:11

se va renderizando constantemente, ¿no? 00:04:12

claro 00:04:13

cada fotograma 00:04:14

en el update 00:04:15

de hecho 00:04:16

se va generando esa nueva imagen 00:04:17

pues según el entorno virtual 00:04:18

pues se verá una cosa u otra 00:04:19

pero 00:04:21

realmente el pixelado 00:04:22

no se va a pixelar nunca 00:04:23

a no ser que metas 00:04:24

una imagen pixelada tú 00:04:25

como un sprite 00:04:26

que ya veremos 00:04:27

pues porque la imagen 00:04:28

ya está pixelada 00:04:29

lo que pasa es que a veces 00:04:30

como tú has hecho instintivamente 00:04:31

para ver 00:04:32

más de cerca la bola 00:04:33

porque has puesto la cámara 00:04:34

un poco lejos 00:04:35

lo que hacemos es usar 00:04:36

el parámetro de escala 00:04:37

pero es 00:04:38

escalar lo que se está viendo 00:04:39

¿vale? 00:04:40

la imagen no se ha pixelado 00:04:41

lo que pasa 00:04:42

es que 00:04:43

la imagen en sí 00:04:44

tiene un tamaño 00:04:45

entonces tú 00:04:46

si haces este escalado 00:04:47

pues 00:04:48

ampliar la imagen 00:04:49

y parece que haces un zoom 00:04:50

pero realmente estás 00:04:51

ampliando la imagen 00:04:52

y se empieza a pixelar 00:04:53

digamos que ya 00:04:54

lo que estás viendo 00:04:55

ahora mismo 00:04:56

es como una foto 00:04:57

ya renderizada 00:04:58

y cada fotograma 00:04:59

será una imagen 00:05:00

renderizada 00:05:01

y tú con la escala 00:05:02

pues estás ampliando 00:05:03

la visualización 00:05:04

pero luego al jugar 00:05:05

esta escala 00:05:06

tú no la vas a poder hacer 00:05:07

esto es sólo 00:05:08

mientras estás 00:05:09

digamos 00:05:10

creando el juego 00:05:11

¿vale? 00:05:12

pero realmente 00:05:13

el tamaño que tiene 00:05:14

ahora mismo 00:05:15

por cómo está configurado 00:05:16

sería este 00:05:17

¿vale? 00:05:18

esto en el último 00:05:19

lo puedes acercar 00:05:20

si quieres 00:05:21

con la cámara 00:05:22

o no y ya está 00:05:23

eso es 00:05:24

¿vale? 00:05:25

luego lo que pasa 00:05:26

es que tienes herramientas 00:05:27

pues para ir 00:05:28

acercándolo 00:05:29

¿no? 00:05:30

como en esta escala 00:05:31

y veremos más adelante 00:05:32

ya en el último tema 00:05:33

seguramente 00:05:34

que incluso se pueden dar 00:05:35

este tamaño 00:05:36

ahora mismo 00:05:37

por ejemplo 00:05:38

es horizontal 00:05:39

y tiene una proporción 00:05:40

panorámica 00:05:41

¿no? 00:05:42

pero 00:05:43

luego podremos ir 00:05:44

cambiando también 00:05:45

la resolución 00:05:46

de la pantalla 00:05:47

y de lo que capta 00:05:48

la cámara 00:05:49

¿no? 00:05:50

pero ahora mismo 00:05:51

tal y como lo tenemos 00:05:52

tenemos esa imagen 00:05:53

que tú 00:05:54

para ver 00:05:55

lo que hay dentro 00:05:56

de esa imagen 00:05:57

más en detalle 00:05:58

pero no es que la imagen 00:05:59

se está haciendo 00:06:00

en sí misma más grande 00:06:01

sino que tú estás 00:06:02

como ampliándola 00:06:03

pero realmente 00:06:04

en el juego 00:06:05

cuando lo ejecutemos 00:06:06

se va a ver 00:06:07

lo que tenemos aquí 00:06:08

ahora mismo 00:06:09

a no ser que 00:06:10

cambiemos otros ingredientes 00:06:11

en el exportado 00:06:12

¿vale? 00:06:13

vale 00:06:14

vale 00:06:15

eso lo primero digo 00:06:16

que como lo he visto 00:06:17

digo ya aprovecho 00:06:18

volvemos a escena 00:06:19

para ir viendo 00:06:20

los elementos que tienes 00:06:21

vale 00:06:22

muy bien 00:06:23

perfecto 00:06:24

y esto no sé 00:06:25

en qué momento 00:06:26

se habrá cambiado 00:06:27

te aconsejo 00:06:28

donde ves el gizmo 00:06:29

de a la derecha 00:06:30

que están los ejes 00:06:31

no 00:06:32

dentro del visor 00:06:33

verás el gizmo 00:06:34

de 00:06:35

en la esquina superior 00:06:36

derecha 00:06:37

están los ejes 00:06:38

bueno 00:06:39

ah sí 00:06:40

los ejes sí 00:06:41

y justo debajo 00:06:42

pone la palabra ISO 00:06:43

que si tú clicas 00:06:44

vas a ver 00:06:45

clica 00:06:46

sin problema 00:06:47

que cambia 00:06:48

a una cámara 00:06:49

con perspectiva 00:06:50

o una isométrica 00:06:51

¿vale? 00:06:52

trabajamos 00:06:53

trabajamos en perspectiva 00:06:54

que es como ve 00:06:55

el ojo humano 00:06:56

y como está también 00:06:57

la cámara de tu juego 00:06:58

cuando le das a play 00:06:59

¿vale? 00:07:00

que es más fácil 00:07:01

trabajar 00:07:02

simplemente eso 00:07:03

vale 00:07:04

ahora mismo 00:07:05

si clicas en el collider 00:07:06

es decir 00:07:07

en el objeto 00:07:08

en la tabla 00:07:09

¿vale? 00:07:10

ahora 00:07:11

para ver yo 00:07:12

los componentes 00:07:13

ahora mismo 00:07:14

lo que tienes 00:07:15

es un mesh collider 00:07:16

¿vale? 00:07:17

y un box collider 00:07:18

y los dos 00:07:19

están activos 00:07:20

vale 00:07:21

un poco por ver 00:07:22

cómo lo has hecho 00:07:23

mira 00:07:24

he hecho un 00:07:25

empty object 00:07:26

un empty object 00:07:27

mira lo ves aquí 00:07:28

he creado un empty object 00:07:29

y entonces 00:07:30

le he asignado un script 00:07:31

que es un collider 00:07:32

¿vale? 00:07:33

que cuando llegue la pelota 00:07:34

cuando la pelota 00:07:35

le he puesto un tag 00:07:36

también 00:07:37

en un tag 00:07:38

he puesto bola 00:07:39

y entonces 00:07:40

cuando llega la pelota 00:07:41

al agujero 00:07:42

toca con el empty object 00:07:43

y desaparece 00:07:44

y cambia de pantalla 00:07:45

pero y 00:07:46

¿qué es lo que está tocando? 00:07:47

perdona 00:07:48

para cambiar de escena 00:07:49

la meta 00:07:50

lo que tienes 00:07:51

lo que tienes la meta 00:07:52

lo ves ¿no? 00:07:53

sí 00:07:54

espera 00:07:55

tengo un enfoco 00:07:56

para que lo veas mejor 00:07:57

vale 00:07:58

y ahí has puesto 00:07:59

un pequeño área 00:08:00

¿no? 00:08:01

vale 00:08:02

el collider lo tienes aquí 00:08:03

¿no? 00:08:04

eso es 00:08:05

perfecto 00:08:06

entonces este 00:08:07

le he asignado un script 00:08:08

que pone aquí abajo 00:08:09

cambio de escena 1 00:08:10

porque esa es la escena 00:08:11

que le he puesto 00:08:12

a través de 00:08:13

el 00:08:14

build settings 00:08:15

build settings 00:08:16

le he puesto 00:08:17

lo tienes aquí 00:08:18

vale 00:08:19

vamos 00:08:20

vale 00:08:21

genial 00:08:22

y entonces 00:08:23

bueno pues eso 00:08:24

y entonces 00:08:25

le he puesto 00:08:26

por cada 00:08:27

por cada pantalla 00:08:28

le he puesto un script 00:08:29

que cambio escena 1 00:08:30

cambio escena 2 00:08:31

cambio escena 3 00:08:32

porque es que no he encontrado 00:08:33

por internet 00:08:34

ninguna forma 00:08:35

de cambiar de escena 00:08:36

automáticamente 00:08:37

vale 00:08:38

ahora lo vemos 00:08:39

de hecho 00:08:40

creo que en el propio enunciado 00:08:41

el que ¿verdad? 00:08:42

sí 00:08:43

que lo he hecho en cada una 00:08:44

por eso te digo 00:08:45

que es que no lo veía 00:08:46

por ninguno 00:08:47

y lo he hecho así 00:08:48

es decir todo lo que sea 00:08:49

ir solucionando problemas 00:08:50

está bien 00:08:51

ahora vamos a ver una forma 00:08:52

de optimizarlo 00:08:53

para con un solo script 00:08:54

que valga en todas las escenas 00:08:55

vale 00:08:56

ahora lo vemos 00:08:57

de todos modos 00:08:58

creo que venía también 00:08:59

en el propio enunciado 00:09:00

venía planteado 00:09:01

pero bueno 00:09:02

entiendo que a veces 00:09:03

aunque ponga código 00:09:04

puede ser que se me ha pasado 00:09:05

no no no 00:09:06

si es normal 00:09:07

porque son muchas piezas 00:09:08

del puzzle 00:09:09

entonces 00:09:10

que de primera saquéis todas 00:09:11

pues 00:09:12

puede atragantarse alguna 00:09:13

no pasa nada 00:09:14

ahora vemos eso 00:09:15

mira dudas que tengo 00:09:16

por ejemplo 00:09:17

en la bola 00:09:18

por ejemplo 00:09:19

igual que te puedo decir 00:09:20

también del terreno 00:09:21

sí 00:09:22

por ejemplo 00:09:23

en material 00:09:24

en el bot collider 00:09:25

ni en el mes collider 00:09:26

no le han 00:09:27

no le ha sido ningún material aquí 00:09:28

vale 00:09:29

por el no physical material 00:09:30

entiendo que no hay 00:09:31

porque me está funcionando 00:09:32

entiendo que no hay 00:09:33

en el caso de la meta 00:09:34

en el caso de la bola 00:09:35

por ejemplo 00:09:36

en el 00:09:37

mes collider 00:09:38

le he metido 00:09:39

uno que me he fabricado 00:09:40

¿no? 00:09:41

materia bola 00:09:42

vale 00:09:43

hay que distinguir varias cosas 00:09:44

bueno 00:09:45

me acabas de decir mes collider 00:09:46

y realmente es 00:09:47

vale 00:09:48

que no es lo mismo 00:09:49

hay dos tipos 00:09:50

si has leído 00:09:51

vamos 00:09:52

en el tema ya se especifica 00:09:53

que hay un tipo de material 00:09:54

que se llama 00:09:55

materiales físicos 00:09:56

o physical materials 00:09:57

vale 00:09:58

que no hay que confundirlos 00:09:59

con 00:10:00

el que estabas señalando 00:10:01

ahora mismo 00:10:02

que son 00:10:03

los materiales de 00:10:04

el shader 00:10:05

de cada geometría 00:10:06

¿qué significa eso? 00:10:07

que cada collider 00:10:08

fíjate 00:10:09

que aunque se llame material 00:10:10

también 00:10:11

vale 00:10:12

tienes ahí un box collider 00:10:13

si te fijas 00:10:14

lo que está buscando 00:10:15

entre paréntesis pone 00:10:16

material físico 00:10:17

y no es exactamente 00:10:18

lo mismo 00:10:19

es decir 00:10:20

el material físico 00:10:21

lo que define es 00:10:22

cómo interactúa 00:10:23

a nivel físico 00:10:24

ese collider 00:10:25

es decir 00:10:26

si va a suponer 00:10:27

que rebota mucho 00:10:28

si va a tener mucho 00:10:29

nivel de fricción 00:10:30

no tiene nada que ver 00:10:31

con lo que se visualiza 00:10:32

vale 00:10:33

no lo he tenido que entender 00:10:34

mira 00:10:35

voy a compartir yo pantalla 00:10:36

un segundo 00:10:39

vale 00:10:40

vale 00:10:41

y vemos este primer nivel 00:10:42

ciertas cosas que me has dicho 00:10:43

las vemos 00:10:44

y luego 00:10:45

seguimos 00:10:46

otra vez 00:10:47

no hay dudas 00:10:48

te parece 00:10:49

cosas que he visto 00:10:50

vamos revisando cosas 00:10:51

vale 00:10:52

lo primero 00:10:53

vale 00:10:54

importante de cara 00:10:55

a seguir avanzando 00:10:56

igual que pasaba 00:10:57

con la nave espacial 00:10:58

tener siempre en cuenta 00:10:59

y pasar la primera tarea 00:11:00

que el eje z 00:11:01

vale 00:11:03

es la profundidad 00:11:04

hacia donde apunta 00:11:05

el eje z 00:11:06

hacia allá 00:11:07

tú Javier 00:11:08

lo tenía justo al revés 00:11:09

es decir 00:11:10

lo tenías 00:11:11

mirando hacia este lado 00:11:13

esto no es problemático 00:11:14

si luego 00:11:15

todo lo configura 00:11:16

bien 00:11:17

pero es verdad 00:11:18

que a la hora de ir 00:11:19

configurando el adelante 00:11:20

y el hacia atrás 00:11:21

siempre va a contar 00:11:22

con estas perspectivas 00:11:23

si estamos usando 00:11:24

los ejes globales 00:11:25

del mundo 00:11:26

vale 00:11:27

entonces 00:11:28

es algo que he visto ahí 00:11:29

que debería 00:11:30

estar orientado 00:11:31

en esa dirección 00:11:32

luego 00:11:33

sobre el tema 00:11:34

de 00:11:35

los colliders 00:11:36

atención 00:11:37

porque en algún elemento 00:11:38

como en la pelota 00:11:39

veo que 00:11:40

en algunos 00:11:41

de los game objects 00:11:42

tienes aplicados 00:11:43

diferentes colliders 00:11:44

y atención 00:11:45

porque a no ser 00:11:46

que lo hagamos a posta 00:11:47

normalmente 00:11:48

un área está definido 00:11:49

por un solo collider 00:11:50

vale 00:11:51

esto 00:11:52

entre comillas 00:11:53

porque luego 00:11:54

podremos ir incorporando más 00:11:55

para que algunos sean 00:11:56

colliders reales 00:11:57

y otros sean triggers 00:11:58

no 00:11:59

que 00:12:00

en esta práctica 00:12:01

ya empezamos a ver 00:12:02

y ahora vamos a ver mucho más 00:12:03

qué es cada cosa 00:12:04

vale 00:12:05

pero si 00:12:06

no tiene marcado 00:12:07

lo de trigger 00:12:08

no debería 00:12:09

por defecto 00:12:10

se puede 00:12:11

pero en este caso 00:12:12

no debería haber 00:12:13

más de un collider 00:12:14

vale 00:12:15

sobre los materiales 00:12:16

vale 00:12:17

me has 00:12:18

empezado indicando 00:12:19

vale 00:12:20

que 00:12:21

claro 00:12:22

que no distinguías 00:12:23

entre el material 00:12:24

que habías creado 00:12:25

con crear 00:12:26

material 00:12:27

vale 00:12:28

pero es que fijaos 00:12:29

que luego hay otro material 00:12:30

es verdad 00:12:31

que lo podrían haber hecho 00:12:32

un poco más intuitivo 00:12:33

pero está 00:12:34

lo que es el material 00:12:35

a nivel visual 00:12:36

por ejemplo 00:12:37

la pelota ahora es azul 00:12:38

y 00:12:39

como cromada 00:12:40

vamos 00:12:41

tiene 00:12:42

metálica 00:12:43

luego está 00:12:44

lo que se llama 00:12:45

el physic material 00:12:46

que es 00:12:47

un material 00:12:48

que sirve para 00:12:49

definir si ese material 00:12:50

pues al botar 00:12:51

con otra superficie 00:12:52

pues rebota 00:12:53

o tiene fricción 00:12:54

es decir 00:12:55

no es lo mismo 00:12:56

en el mundo real 00:12:57

que 00:12:58

la fricción 00:12:59

de una acera 00:13:00

sea de 00:13:01

voy a poner números 00:13:02

sea muy dura 00:13:03

o muy blanda 00:13:04

es decir 00:13:05

tú puedes ir andando 00:13:06

por la misma acera 00:13:07

y que 00:13:08

no resbales 00:13:09

cuando vas andando 00:13:10

porque tiene mucha fricción 00:13:11

o que no tenga ninguna 00:13:12

nada 00:13:13

vale 00:13:14

y tiene una capita de hielo 00:13:15

que entonces la fricción 00:13:16

no es ninguna 00:13:17

tener en cuenta 00:13:18

que los colliders 00:13:19

lo que definen 00:13:20

son 00:13:21

los límites físicos 00:13:22

vale 00:13:23

contra los que colisiona 00:13:24

un objeto con otro 00:13:25

vale 00:13:26

sin collider 00:13:27

es imposible 00:13:28

que los elementos 00:13:29

sepan 00:13:30

dónde están los límites 00:13:31

con los que tienen que coleccionar 00:13:32

es decir 00:13:33

si yo por ejemplo 00:13:34

vale 00:13:35

a esta pelota 00:13:36

que tiene este 00:13:37

sphere collider 00:13:38

lo desactivo 00:13:39

temporalmente 00:13:40

vais a ver 00:13:41

que la pelota 00:13:42

le doy ahora al play 00:13:43

vamos 00:13:44

lo reproduzco 00:13:45

que la pelota 00:13:46

choque contra el suelo 00:13:47

vale 00:13:48

todo elemento 00:13:49

que sirva 00:13:50

o que tenga que tener 00:13:51

corporeidad 00:13:52

por decirlo así 00:13:53

que algo colisione 00:13:54

con ello 00:13:55

tiene que tener 00:13:56

algún collider 00:13:57

de un tipo u otro 00:13:58

vale 00:13:59

y por defecto 00:14:00

esa es la función 00:14:01

de un collider 00:14:02

que colisionen objetos 00:14:03

entre sí 00:14:04

vale 00:14:05

entonces 00:14:06

cuando 00:14:07

tenemos además 00:14:08

un collider 00:14:09

todos los colliders 00:14:10

que son los que marcan 00:14:11

los límites 00:14:12

tienen ese material 00:14:13

pero que está 00:14:14

relacionado 00:14:15

con un 00:14:16

physic material 00:14:17

vale 00:14:18

los apuntes 00:14:19

simplemente 00:14:20

para que lo podáis revisar 00:14:21

si abro el tema 3 00:14:22

si no me equivoco 00:14:23

la última parte 00:14:24

los materiales 00:14:25

visuales 00:14:26

como es azul 00:14:27

que he indicado antes 00:14:28

no los hemos estudiado 00:14:29

menos alguna mención 00:14:31

muy pequeña 00:14:32

pero los materiales físicos 00:14:33

sí que es 00:14:34

esta última sección 00:14:35

y aquí se habla de ello 00:14:36

vale 00:14:37

los materiales 00:14:38

del mesh renderer 00:14:39

que es lo que hace 00:14:40

la visualización 00:14:41

del juego 00:14:42

vale 00:14:43

que son estos materiales 00:14:44

y luego están 00:14:45

los materiales físicos 00:14:46

que son 00:14:47

los que 00:14:48

tienen las opciones 00:14:49

de fricción 00:14:50

y de bote 00:14:51

vale 00:14:52

entonces 00:14:53

ahora hacemos algún ejemplo 00:14:54

pero distinguir 00:14:55

esos dos materiales 00:14:56

hay dos tipos de materiales 00:14:57

y además se identifican 00:14:58

por 00:14:59

el icono que tiene 00:15:00

vale 00:15:01

lo voy a crear aquí 00:15:02

si yo creo 00:15:03

un material 00:15:04

para visualizarlo 00:15:05

a través de un renderer 00:15:06

vale 00:15:07

pues 00:15:08

tiene este icono 00:15:09

de bola 00:15:10

de 00:15:11

de 00:15:12

shader 00:15:13

de 00:15:14

de 00:15:15

programa de 3d 00:15:16

vale 00:15:17

y saldrá el material aquí 00:15:18

que nosotros ya 00:15:19

podremos ir cambiando de color 00:15:20

o ponerle 00:15:21

como venía en la escena 00:15:22

las texturas 00:15:23

lo hago muy rápido 00:15:24

en 00:15:25

el canal albedo 00:15:26

que esto ya habéis estudiado 3d 00:15:27

como habéis hecho en otros módulos 00:15:28

antes de color 00:15:30

etcétera 00:15:31

pues son los distintos pases 00:15:32

digamos 00:15:33

los canales 00:15:34

que tiene este material 00:15:35

vale 00:15:36

ahora mismo 00:15:37

cuando estamos hablando mucho 00:15:38

de materiales 00:15:39

de más visual 00:15:40

me voy a centrar más 00:15:41

casi 00:15:42

en el material físico 00:15:43

vuelvo aquí 00:15:44

si 00:15:45

donde 00:15:46

a ver 00:15:47

porque lo he creado aquí 00:15:48

si en vez de crear un material 00:15:49

creo un physics material 00:15:50

vale 00:15:51

un material para físicas 00:15:52

lo que se genera 00:15:53

es este icono 00:15:54

vale 00:15:55

y estas opciones 00:15:56

es bastante más simple 00:15:57

entonces 00:15:58

este material 00:15:59

vamos a decir 00:16:00

que es 00:16:01

goma 00:16:02

o 00:16:03

cama elástica 00:16:04

cama elástica 00:16:05

aquí 00:16:06

vale 00:16:07

y yo le digo 00:16:08

que es goma elástica 00:16:09

que lo voy a usar 00:16:10

por ejemplo 00:16:11

en 00:16:12

el 00:16:13

en el mes colider 00:16:14

que tiene 00:16:15

bueno 00:16:16

yo ya tengo un aplicado 00:16:17

que se llama madera 00:16:18

pero os lo voy a poner 00:16:19

en este que tengo aquí 00:16:20

vale 00:16:21

lo cambio un segundo 00:16:22

uno 00:16:23

que 00:16:24

está aplicado 00:16:25

a la superficie 00:16:26

de la madera 00:16:27

de la 00:16:28

del 00:16:29

de la plataforma 00:16:30

vale 00:16:31

entonces 00:16:32

si yo esa cama elástica 00:16:33

por ejemplo 00:16:34

le digo que tenga 00:16:35

un bote 00:16:36

elevadísimo 00:16:37

vais a ver 00:16:38

que 00:16:39

la pelota 00:16:40

cuando cae 00:16:41

da ese bote 00:16:42

vale 00:16:43

ese bote 00:16:44

y tal 00:16:45

es decir 00:16:46

porque le he puesto un límite 00:16:47

de bote 00:16:48

muy alto 00:16:49

si yo le pusiera acero 00:16:50

el material sigue aplicado 00:16:51

vale 00:16:52

he cambiado la opción del material 00:16:53

y veis que cae a plomo 00:16:54

no tiene ningún tipo de bote 00:16:55

no es una cama elástica 00:16:56

es una plancha de acero 00:16:57

vale 00:16:58

para hacer una idea 00:16:59

entonces 00:17:00

esos materiales sirven para eso 00:17:01

ojo 00:17:02

porque claro 00:17:03

ahora mismo son dos 00:17:04

los elementos que están colisionando 00:17:05

la bola 00:17:06

y de hecho aquí la tengo 00:17:07

acero 00:17:08

ya la había hecho yo uno 00:17:09

eh 00:17:10

la propia 00:17:11

la propia 00:17:12

pelota 00:17:13

también podría ser de goma 00:17:14

si yo le pongo cama elástica 00:17:15

y a los dos 00:17:16

les digo que tengan muchísimo bote 00:17:17

cuando le da al play 00:17:18

va a dar un bote aún mayor 00:17:19

fijaos qué pedazo de bote 00:17:20

vale 00:17:21

porque estamos juntando 00:17:22

y de hecho no va a dejar de botar 00:17:23

porque tienen 00:17:24

los dos elementos 00:17:25

el bote máximo 00:17:26

la pelota por un lado 00:17:27

que es como si fuera una 00:17:28

pelota de tenis 00:17:29

que bota mucho 00:17:30

no 00:17:31

es el ejemplo que se me ocurre 00:17:32

y además 00:17:33

si yo le pongo 00:17:34

cama elástica 00:17:35

es el ejemplo que se me ocurre 00:17:36

y aparte 00:17:37

lo estuviéramos tirando 00:17:38

una cama elástica 00:17:39

entonces el bote es 00:17:40

mmm 00:17:41

muy elevado 00:17:42

con la fricción 00:17:43

y esto 00:17:44

también 00:17:45

tiene influencia 00:17:46

pues 00:17:47

en el nivel 2 00:17:48

si pusiéramos una caja de madera 00:17:49

y estamos volcando 00:17:50

eh 00:17:51

la plataforma 00:17:52

la fricción 00:17:53

es 00:17:54

básicamente 00:17:55

cuánta resistencia 00:17:56

va a tener 00:17:57

el objeto 00:17:58

con respecto a la plataforma 00:17:59

es decir 00:18:00

la plataforma 00:18:01

si oscila un poco 00:18:02

y es de hielo 00:18:03

tendrá muy poca fricción 00:18:04

vale 00:18:05

pero si es 00:18:06

eh 00:18:07

pues de 00:18:08

a ver 00:18:09

por ejemplo 00:18:10

de gravilla 00:18:11

la fricción es mucho menor 00:18:12

y no se va a ir desplazando 00:18:13

se va a detener enseguida 00:18:14

vale 00:18:15

esa es la función de él 00:18:16

los materiales físicos 00:18:17

que siempre van 00:18:18

asociados al collider 00:18:19

vale 00:18:20

al collider 00:18:21

a los distintos colliders 00:18:22

todos tendrán 00:18:24

algún 00:18:25

eh 00:18:26

alguna sección de material 00:18:27

y luego el mesh renderer 00:18:28

que si recordáis 00:18:29

era 00:18:30

el componente 00:18:31

que viene por defecto 00:18:32

las geometrías 00:18:33

para asignar 00:18:34

pues que 00:18:35

este elemento 00:18:36

ahí hay otro material 00:18:37

esto ya veremos 00:18:38

más adelante 00:18:39

que son 00:18:40

los materiales visuales 00:18:41

vale 00:18:42

que son 00:18:43

los dos que vemos aquí 00:18:44

de diferente tipo 00:18:45

vale 00:18:46

hasta aquí qué tal 00:18:47

esto 00:18:48

que es importante 00:18:49

que distingáis 00:18:50

que aunque ponga material 00:18:51

en ambos casos 00:18:52

vale 00:18:53

no tiene nada que ver 00:18:54

vale 00:18:55

vuelvo para atrás 00:18:56

que quiero dejarlo 00:18:57

como estaba 00:18:58

para que no sea 00:18:59

una cama elástica 00:19:00

como 00:19:01

qué tal 00:19:02

entonces 00:19:03

una pregunta 00:19:04

qué es el material 00:19:05

es decir 00:19:06

el bote 00:19:07

la fricción 00:19:08

y todo eso 00:19:09

eso es un material físico 00:19:10

eso es 00:19:11

o sea solamente 00:19:12

las características físicas 00:19:13

del material 00:19:14

pero no las visuales 00:19:15

las visuales serían 00:19:16

en el renderer 00:19:17

no 00:19:18

efectivamente 00:19:19

y la forma de interactuar 00:19:20

de un material con el otro 00:19:21

entonces tiene que ser 00:19:22

a través del material físico 00:19:23

efectivamente 00:19:24

el material 00:19:25

es decir 00:19:26

el 00:19:27

que la bola se ve azul 00:19:28

y donde yo lo defino 00:19:29

en el mes renderer 00:19:30

vale 00:19:31

con este tipo de material 00:19:32

que tengo aquí 00:19:33

es sólo visual 00:19:34

vale 00:19:35

el material físico 00:19:36

como dice su nombre 00:19:37

fijaos el icono 00:19:38

de hecho 00:19:39

mira 00:19:40

es casi lo que he dicho 00:19:41

una pelota de tenis 00:19:42

contra una cama 00:19:43

una placa 00:19:44

esto es lo que 00:19:45

y si clicáis aquí 00:19:46

fijaos las opciones que salen 00:19:47

todas están relacionadas 00:19:48

con la fricción 00:19:49

y el bote 00:19:50

vale 00:19:51

no tiene nada visual 00:19:52

y una 00:19:53

se va a asociar 00:19:54

en el collider 00:19:55

vale 00:19:56

y nuevamente 00:19:57

esto se ve 00:19:58

en el momento 00:19:59

que tengáis dudas 00:20:00

por decirlo así 00:20:01

si cuando por defecto 00:20:02

lo que os pide aquí 00:20:03

no es un material 00:20:04

pone 00:20:05

physic material 00:20:06

porque lo que está buscando 00:20:07

aunque yo arrastre 00:20:08

este material visual 00:20:09

no me lo coge 00:20:10

porque ese campo 00:20:11

está pensado 00:20:12

para arrastrar 00:20:13

materiales físicos 00:20:14

vale 00:20:15

entonces otra pregunta 00:20:16

dime dime 00:20:17

si yo por ejemplo 00:20:18

quiero que 00:20:19

que un material interactúe 00:20:20

con otro 00:20:21

con el mes 00:20:22

con el collider 00:20:23

con un collider 00:20:24

por ejemplo 00:20:25

que le pegas contra 00:20:26

o al malo 00:20:27

le pegas contra una pared 00:20:28

sí 00:20:29

y en vez de estamparse 00:20:30

rebota 00:20:31

lo tengo que hacer todo 00:20:32

el material físico 00:20:33

en el collider 00:20:34

no 00:20:35

claro 00:20:36

aquí se suman dos cosas 00:20:37

el comportamiento 00:20:38

que tienen en sí mismo 00:20:39

los materiales 00:20:40

cuando colisionan 00:20:41

qué es lo que has dicho 00:20:42

tú imagínate 00:20:43

que estás 00:20:44

pues eso 00:20:45

lanzando una pelota 00:20:46

contra una pared 00:20:47

vale 00:20:48

pues ya las materiales 00:20:49

las propiedades 00:20:50

del material físico 00:20:51

va a permitir 00:20:52

que el rebote 00:20:53

de esa pelota 00:20:54

al chocar 00:20:55

sea de una forma 00:20:56

u otra 00:20:57

vale 00:20:58

un poco la lógica 00:20:59

es pensar eso 00:21:00

que una pelota 00:21:01

sea de goma 00:21:02

está contra la pared 00:21:03

y puede que hasta la rompa 00:21:04

vale 00:21:05

luego aparte 00:21:06

también está 00:21:07

que tú puedes 00:21:08

por código 00:21:09

decir 00:21:10

cuando choque la pelota 00:21:11

tenga el material físico 00:21:12

que tenga 00:21:13

que al chocar 00:21:14

contra la pared 00:21:15

y detectarse la colisión 00:21:16

que se aplique una fuerza 00:21:17

en orden 00:21:18

en 00:21:19

la dirección contraria 00:21:20

se puede hacer 00:21:21

de varias formas 00:21:22

y se pueden combinar 00:21:23

las distintas formas 00:21:24

pero 00:21:25

una cosa 00:21:26

hay que pensar 00:21:27

que es 00:21:28

las propiedades intrínsecas 00:21:29

del propio objeto 00:21:30

que serían 00:21:31

las de ese material físico 00:21:32

asignado 00:21:33

no es solo crear el material 00:21:34

es luego asignárselo 00:21:35

al collider 00:21:36

vale 00:21:37

y luego por otro lado 00:21:38

tú también por código 00:21:39

puedes añadir fuerzas 00:21:40

como estamos haciendo aquí 00:21:41

con estos 00:21:42

add force 00:21:43

y add torque 00:21:44

vale 00:21:45

no sé si me 00:21:46

si me 00:21:47

vais entendiendo 00:21:48

si no 00:21:49

sigo con ello 00:21:50

lo 00:21:51

lo 00:21:52

explico de otra forma 00:21:53

a ver que no sé 00:21:54

si me estáis escribiendo 00:21:55

por el chat 00:21:56

vale 00:21:57

yo entiendo 00:21:58

si la pelota 00:21:59

pones 00:22:00

para que 00:22:01

se produzca 00:22:02

digamos 00:22:03

un rebote 00:22:04

solo afectaría 00:22:05

a la superficie 00:22:06

contra 00:22:07

lo que 00:22:08

has programado 00:22:09

quiero decir 00:22:10

si lo has programado 00:22:11

para que rebote 00:22:12

en el suelo 00:22:13

pero choca 00:22:14

contra otra superficie 00:22:15

no funcionaría 00:22:16

no 00:22:17

claro 00:22:18

ahora vamos a ver 00:22:19

que 00:22:20

todo lo que 00:22:21

vamos teniendo 00:22:22

luego 00:22:23

de diferentes modos 00:22:24

se puede ir discriminando 00:22:25

que si este objeto 00:22:26

choca con este objeto 00:22:27

haga una cosa 00:22:28

si este objeto 00:22:29

choca contra el 00:22:30

colíder 00:22:31

que tenemos aquí 00:22:32

trigger 00:22:33

por ejemplo 00:22:34

de aquí 00:22:35

vale 00:22:36

que haga otra cosa 00:22:37

es decir 00:22:38

si 00:22:39

luego por código 00:22:40

tendremos que ir discriminando 00:22:41

que hace cada 00:22:42

cada colisión 00:22:43

digamos 00:22:44

que desencadena 00:22:45

el otro día 00:22:46

mira 00:22:47

para poneros un ejemplo 00:22:48

que igual 00:22:49

es más 00:22:50

develador 00:22:51

don't save 00:22:52

vale 00:22:53

en el último nivel 00:22:54

que este no lo 00:22:55

no se pide 00:22:56

vale 00:22:57

la tarea 00:22:58

pero para explicar esto 00:22:59

igual que en el nivel 00:23:00

2 y 3 00:23:01

pues que se mueva 00:23:02

se mueve la 00:23:03

la plataforma 00:23:04

oscila 00:23:05

pero si choca 00:23:06

con esos elementos 00:23:07

y fijaos 00:23:08

que yo en la bola 00:23:09

tengo el material acero 00:23:10

mismo 00:23:11

que tenía la otra escena 00:23:12

y en 00:23:13

en la madera 00:23:14

a ver 00:23:15

en el 00:23:16

intermedio 00:23:17

tenía 00:23:18

bueno 00:23:19

no lo tengo puesto 00:23:20

pero lo puedo poner 00:23:21

el de madera 00:23:22

vale 00:23:23

vais a ver 00:23:24

que aún así 00:23:25

cuando choque 00:23:26

con uno de los pivotes 00:23:27

si tiene bastante 00:23:28

energía 00:23:29

lo que hace es 00:23:30

repelerlo 00:23:31

hacia otro 00:23:32

hacia el otro lado 00:23:33

fijaos que yo 00:23:34

ahora cuando se choque 00:23:35

va a hacer pum 00:23:36

y sale disparado 00:23:37

eso no es por los materiales físicos 00:23:38

eso es porque yo he dicho 00:23:39

que cuando choque 00:23:40

esta bola 00:23:41

con uno de los pivotes 00:23:42

le implique 00:23:43

le aplique una fuerza 00:23:44

contraria 00:23:45

vale 00:23:46

yo ahora mismo aquí 00:23:47

si voy a 00:23:48

cualquiera de estos pivotes 00:23:49

lo selecciono 00:23:50

desde la escena 00:23:51

vale 00:23:52

vais a ver 00:23:53

que tengo un script 00:23:54

que si me meto 00:23:55

vale 00:23:56

lo que va a hacer es 00:23:57

a este capsule collider 00:23:58

que le aplique una fuerza 00:23:59

en dirección contraria 00:24:00

vale 00:24:01

esto es más avanzado 00:24:02

a nivel de programación 00:24:03

pero el concepto 00:24:04

fijaos que el material físico 00:24:05

realmente 00:24:06

no es el que está haciendo 00:24:07

ese rebote 00:24:08

es el código 00:24:09

que cuando 00:24:10

colisionan dos objetos 00:24:11

hace pum 00:24:12

y le empuja 00:24:13

hacia el otro lado 00:24:14

vale 00:24:15

pero sí que por defecto 00:24:16

los materiales 00:24:17

ya pueden tener 00:24:18

su propio comportamiento físico 00:24:19

ya por defecto 00:24:20

tened en cuenta 00:24:21

que todo lo que estábamos 00:24:22

estudiando en el tema 3 00:24:23

es simulaciones físicos 00:24:24

para que se parezca 00:24:25

un poco 00:24:26

a los comportamientos 00:24:27

pues del mundo real 00:24:28

pero luego nosotros 00:24:29

por código 00:24:30

podemos seguir moviendo 00:24:31

con el transform 00:24:32

y podemos seguir 00:24:33

que se van acumulando 00:24:34

las opciones 00:24:36

pero el material físico 00:24:37

da por defecto 00:24:38

ya por 00:24:39

según lo asignamos 00:24:40

pues tiene un tipo 00:24:41

de comportamiento 00:24:42

sí 00:24:44

qué tal 00:24:47

vale 00:24:49

más cosas 00:24:51

dicho esto 00:24:52

sigo 00:24:53

vale 00:24:54

más o menos lo entendéis 00:24:55

es que trasteéis 00:24:56

esto se prueba 00:24:57

poniendo una superficie 00:24:58

o lo podéis hacer 00:24:59

en este nivel 00:25:00

y ir aplicar 00:25:01

a los colliders 00:25:02

que tengáis 00:25:03

en cada uno de los elementos 00:25:04

un material físico 00:25:05

e ir cambiando 00:25:06

las opciones 00:25:07

de material físico 00:25:08

y vais a ir viendo 00:25:09

que la reacción 00:25:10

como hemos hecho antes 00:25:11

que cuando se ha puesto 00:25:12

a votar sin yo 00:25:13

hacer nada más 00:25:14

ya varía mucho 00:25:15

si alguien ha pedido 00:25:16

la palabra creo 00:25:17

si yo mira 00:25:18

una pregunta también 00:25:19

mira 00:25:20

por ejemplo 00:25:21

en el caso de que 00:25:22

me oyes no 00:25:23

sí sí sí 00:25:24

mira por ejemplo 00:25:25

que no te sale un terreno 00:25:26

collider 00:25:27

y un terreno 00:25:28

por ejemplo 00:25:29

dentro 00:25:30

como si fueran 00:25:31

hijos del primero 00:25:32

sí 00:25:33

entonces en ese caso 00:25:34

le asignarle 00:25:35

le asignan 00:25:36

los materiales 00:25:37

o los colliders 00:25:38

o los real body 00:25:39

al padre 00:25:40

pero no a los hijos 00:25:41

vale 00:25:42

esto está hecho 00:25:43

vale 00:25:44

para reutilizar 00:25:45

parte del trabajo 00:25:46

de este nivel 00:25:47

al siguiente nivel 00:25:48

pero 00:25:49

realmente 00:25:50

del nivel 1 00:25:51

al nivel 2 00:25:52

cómo se puede configurar 00:25:53

la plataforma 00:25:54

es muy diferente 00:25:55

vale 00:25:56

yo ahora mismo 00:25:57

para que te hagas una idea 00:25:58

si quito 00:25:59

lo voy a desactivar 00:26:00

si quito 00:26:01

espero no equivocarme 00:26:02

yo creo que no 00:26:03

si quito este terreno padre 00:26:04

para que no te distraigan 00:26:05

este caso 00:26:06

luego os explico 00:26:07

en el nivel 2 00:26:08

porque estaba uno hijo de otro 00:26:09

vale 00:26:10

va a ser lo mismo 00:26:11

es decir 00:26:12

ahora mismo funciona igual 00:26:13

vale 00:26:14

entonces ahora mismo 00:26:15

no te centres 00:26:16

en este 00:26:17

en este que tengo aquí 00:26:18

céntrate en este 00:26:19

vale 00:26:20

aquí lo que tengo 00:26:21

vale 00:26:22

y esto es igual 00:26:23

en el nivel 1 00:26:24

2 y 3 00:26:25

lo que 00:26:26

ponía en el enunciado 00:26:27

y la forma de hacerlo 00:26:28

es 00:26:29

que se tiene que usar 00:26:30

en el terreno 00:26:31

un mes collider 00:26:32

aparte de porque 00:26:33

es el que por defecto 00:26:34

traen las geometrías 00:26:35

que importamos 00:26:36

como estos fbx 00:26:37

porque tiene 00:26:38

alguna particularidad 00:26:39

que es 00:26:40

que tú si metes 00:26:41

un box collider 00:26:42

un capsule collider 00:26:43

un sphere collider 00:26:44

los que son como 00:26:45

de formas nativas 00:26:46

el problema 00:26:47

es que no podemos conseguir 00:26:48

a ver amplio aquí 00:26:49

que este agujero 00:26:50

se vea 00:26:51

interpretado 00:26:52

como collider 00:26:53

es decir 00:26:54

yo puedo 00:26:55

a esta plataforma 00:26:56

desactivo el mes collider 00:26:57

y digo 00:26:58

lo que voy a hacer 00:26:59

en vez de un mes collider 00:27:00

es 00:27:01

ponerle un 00:27:02

box collider 00:27:03

vale 00:27:04

porque como es una forma 00:27:05

de prisma 00:27:06

de caja 00:27:07

vale 00:27:08

y yo la tengo ahí 00:27:09

perfecto 00:27:10

pero fijaos que 00:27:11

ahora mismo 00:27:12

y esto 00:27:13

también un truco 00:27:14

a veces no se ve muy bien 00:27:15

los límites de los colliders 00:27:16

que son estas líneas verdes 00:27:17

para 00:27:18

mientras trabajamos 00:27:19

si ponemos el modo 00:27:20

wireframe 00:27:21

vale 00:27:22

son las de 00:27:23

la geometría 00:27:24

las de la malla 00:27:25

y las verdes son 00:27:26

las de 00:27:27

el collider en sí 00:27:28

vale 00:27:29

en este caso 00:27:30

el que está activo 00:27:31

que es el box collider 00:27:32

yo vale 00:27:33

puedo decir vale 00:27:34

tengo aquí un collider 00:27:35

y efectivamente 00:27:36

me voy aquí al juego 00:27:37

fijaos que la bola 00:27:38

no se cae 00:27:40

se va 00:27:41

moviendo por ahí 00:27:42

y cuando llego al agujero 00:27:43

pues 00:27:44

muy bien 00:27:45

pero veis que se queda flotando 00:27:46

porque nosotros le estamos diciendo 00:27:47

que el límite 00:27:49

sea 00:27:50

es decir 00:27:51

no estamos distinguiendo 00:27:52

en ningún momento 00:27:53

que aquí haya 00:27:54

nada 00:27:55

que diga que 00:27:56

se puede introducir por aquí 00:27:57

a nivel físico 00:27:58

ahora mismo es una caja 00:27:59

vale 00:28:00

entonces 00:28:01

un poco para forzaros también 00:28:02

a que 00:28:03

veáis cómo funciona 00:28:04

el mes collider 00:28:05

vale 00:28:06

o en ejemplos en el que 00:28:07

voy a borrar ya este 00:28:08

este box collider de ejemplo 00:28:09

vale 00:28:10

que es 00:28:11

que cuando metemos la geometría 00:28:12

nos crea directamente 00:28:13

el mes collider 00:28:14

y el mes collider 00:28:15

por defecto 00:28:16

lo que intenta es 00:28:17

adaptarse a una geometría 00:28:18

vale 00:28:20

entonces yo ahora mismo 00:28:21

este terreno 1 collider 00:28:22

que lo puedo quitar 00:28:24

vale 00:28:25

para que veáis el ejemplo 00:28:26

si yo meto el mes collider 00:28:27

y no hay 00:28:28

ningún tipo de 00:28:29

indicación 00:28:31

de cuál es 00:28:32

esa malla 00:28:33

que tenemos aquí 00:28:34

vale 00:28:35

pues 00:28:36

no estamos 00:28:37

el mes collider 00:28:38

aunque esté aplicado 00:28:39

no está aplicando nada 00:28:40

vale 00:28:41

no tiene la malla 00:28:42

en la que funcionar 00:28:43

entonces 00:28:44

en el tema 00:28:45

también se explica 00:28:46

que 00:28:47

los propios 00:28:48

los propios fbx 00:28:49

se pueden 00:28:50

descomponer 00:28:51

en sus partes 00:28:52

es decir 00:28:53

en la malla 00:28:54

en el collider 00:28:55

y en el 00:28:56

y en el material que tiene 00:28:57

al material visual 00:28:58

me refiero 00:28:59

vale 00:29:00

yo cuando creo ese terreno 00:29:01

le puedo decir 00:29:02

vale 00:29:03

he metido esta geometría 00:29:04

y quiero que el collider 00:29:05

que por defecto 00:29:06

debería venir asignado 00:29:07

es 00:29:08

el del propio 00:29:09

la propia geometría 00:29:10

lo que pasa a veces 00:29:11

bueno 00:29:12

y estoy aplicando 00:29:13

la del collider 00:29:14

la preparada 00:29:15

perdona 00:29:16

vendría así 00:29:17

aplicada 00:29:18

vale 00:29:19

y la otra vez 00:29:20

lo que hice 00:29:21

es que 00:29:22

al final 00:29:23

de la tutoría 00:29:24

del otro día 00:29:25

lo que hice 00:29:26

fue tocar 00:29:27

el factor de escala 00:29:28

del 00:29:29

del 00:29:30

fbx 00:29:31

vale 00:29:32

que os hablé 00:29:33

de que bueno 00:29:34

que según 00:29:35

del programa 00:29:36

que vengamos 00:29:37

a veces hay que cambiar 00:29:38

las unidades de medida 00:29:39

entonces 00:29:40

como veis aquí 00:29:41

a veces puede haber 00:29:42

problemas de interpretación 00:29:43

de la malla 00:29:44

vale 00:29:45

por eso 00:29:46

se os 00:29:47

asignaba 00:29:48

se os 00:29:49

asignaba 00:29:50

a ver 00:29:51

un segundín 00:29:52

tenemos aquí 00:29:53

la malla 00:29:54

perdona 00:29:55

que lo que estoy haciendo 00:29:56

es aplicar 00:29:57

la otra que tengo aquí 00:29:58

si yo aplico 00:29:59

esta malla aquí 00:30:00

esta no 00:30:01

está cogiendo 00:30:02

el collider 00:30:03

todo 00:30:04

vale 00:30:05

que pueda haber momentos 00:30:06

en el que no funcione 00:30:07

esa geometría 00:30:08

por eso a veces 00:30:09

lo que se hace 00:30:10

es sacar 00:30:11

una versión 00:30:12

del programa 3d 00:30:13

que es una versión reducida 00:30:14

de esa malla 00:30:15

vale 00:30:16

porque los mes collider 00:30:17

tienen un límite de geometría 00:30:18

como si os fijáis aquí 00:30:19

por ejemplo 00:30:20

tenemos 00:30:21

una 00:30:22

una 00:30:23

una 00:30:24

malla 00:30:25

que se ajusta 00:30:26

al tamaño 00:30:27

de la 00:30:28

de la geometría 00:30:29

pero tiene mucho menos 00:30:30

mucho menos polígonos 00:30:31

vale 00:30:32

y aparte 00:30:33

está proporcionando 00:30:34

esta 00:30:35

forma de agujero 00:30:36

que tiene 00:30:37

vale 00:30:38

por eso 00:30:39

cuando le damos al play 00:30:40

y me meto 00:30:41

vale 00:30:42

ahora sí que va a interpretar 00:30:43

que yo cuando me meta ahí 00:30:44

pues hay un hueco 00:30:45

entonces 00:30:46

yo me meteré 00:30:47

más 00:30:48

no me meto todavía 00:30:49

aquí tengo preparado 00:30:50

un collider 00:30:51

eh 00:30:52

definido como trigger 00:30:53

que me hará 00:30:54

que cambie de nivel 00:30:55

vale 00:30:56

hasta que no me he metido 00:30:57

no ha sido posible 00:30:58

pero nada 00:30:59

que yo me meta 00:31:00

en este agujero 00:31:01

en el que yo tengo aquí 00:31:02

ved otro game object 00:31:03

separado 00:31:04

vale 00:31:05

que está ahí 00:31:06

que es ese de meta 00:31:07

tengo aquí 00:31:08

este 00:31:09

esta cajita 00:31:10

que es lo que tú habías hecho 00:31:11

javier 00:31:12

esta cajita 00:31:13

esperando 00:31:14

a desencadenar 00:31:15

cosas 00:31:16

para que coja 00:31:17

la forma 00:31:18

de 00:31:19

el 00:31:20

elemento 00:31:21

o si no 00:31:22

pasársela 00:31:23

por este parámetro 00:31:24

mes 00:31:25

al 00:31:26

a la misma geometría 00:31:27

es decir 00:31:28

se está metiendo 00:31:29

la geometría 00:31:30

de un objeto simplificado 00:31:31

en otro 00:31:32

que es el que venía 00:31:33

por defecto 00:31:34

vale 00:31:35

es cierto que 00:31:36

realmente 00:31:37

esto es una operación 00:31:38

muy conveniente 00:31:39

para 00:31:40

para asignar 00:31:41

el collider 00:31:42

pero por defecto 00:31:43

cuando metemos el fbx 00:31:44

aquí no lo está cogiendo bien 00:31:45

por eso 00:31:46

que hemos cambiado 00:31:47

el tamaño 00:31:48

de la proporción 00:31:49

del 00:31:50

de 00:31:51

la malla 00:31:52

pero por defecto 00:31:53

debería venir ya 00:31:54

con una 00:31:55

geometría vale 00:31:56

aquí aunque no se vea 00:31:57

sí que es verdad 00:31:58

que tiene 00:31:59

la propia forma 00:32:00

del 00:32:01

terreno 00:32:02

vale y yo 00:32:03

cuando llegue 00:32:04

se va a meter 00:32:05

pero 00:32:06

tener en cuenta 00:32:07

que no se ve 00:32:08

porque se está adaptando 00:32:09

a todas 00:32:10

las superficies 00:32:11

de 00:32:12

al poligonaje 00:32:13

de la malla 00:32:14

a veces para que funcione bien 00:32:15

es necesario 00:32:16

una versión simplificada 00:32:17

que por eso 00:32:18

estaba ese ejercicio 00:32:19

de asigna 00:32:20

al mes collider 00:32:21

un terreno 00:32:22

que 00:32:23

se corresponda 00:32:24

con la versión simplificada 00:32:25

vale en cualquiera 00:32:26

de los casos 00:32:27

cuando tenemos 00:32:28

este mes collider 00:32:29

funcionando 00:32:30

hay una opción aquí 00:32:31

que se puede marcar 00:32:32

y desmarcar 00:32:33

que lo que sirve 00:32:34

es primero 00:32:35

para poder 00:32:36

convertir 00:32:37

esta caja 00:32:38

en un trigger 00:32:39

ahora vemos lo que es un trigger 00:32:40

aunque viene del tema 00:32:41

y también 00:32:42

porque 00:32:43

lo que hace es simplificar 00:32:44

la geometría 00:32:45

imaginaos 00:32:46

que no nos interesa 00:32:47

el detalle 00:32:48

ten en cuenta 00:32:49

que todo el polígono 00:32:50

que vaya metiendo 00:32:51

en la geometría 00:32:52

o en los colliders 00:32:53

son recursos 00:32:54

que va a ir gastando 00:32:55

para ir calculando 00:32:56

cómo funciona el juego 00:32:57

entonces 00:32:58

en ocasiones 00:32:59

nos interesa 00:33:00

que se simplifiquen 00:33:01

las mallas 00:33:02

si andamos al convex 00:33:03

el problema que hay 00:33:04

es que nuevamente 00:33:05

hemos convertido esto 00:33:06

en una caja 00:33:07

y nos hemos cargado 00:33:08

el agujero 00:33:09

aunque la malla 00:33:10

que hemos metido asociada 00:33:11

sí que tiene el agujero 00:33:12

vale 00:33:13

por efecto 00:33:14

viene así 00:33:15

y aquí 00:33:16

de momento 00:33:17

nos interesa 00:33:18

que sea convex 00:33:19

para que tenga 00:33:20

ese agujero 00:33:21

vale 00:33:22

entonces 00:33:23

esto es 00:33:24

ir definiendo 00:33:25

cómo funciona el collider 00:33:26

y qué límites tiene 00:33:27

en el caso de 00:33:28

una forma 00:33:29

que no es primitiva 00:33:30

que no es un cubo 00:33:31

que no es una esfera 00:33:32

suelen tener 00:33:33

pues 00:33:34

formas 00:33:35

más complejas 00:33:36

que las de 00:33:37

las que nos proporciona 00:33:38

un collider 00:33:39

de tipo box 00:33:40

o de los que vienen 00:33:41

asociados a primitivas 00:33:42

para eso 00:33:43

intenta adaptar 00:33:44

a la forma 00:33:45

de la malla 00:33:46

pues por ejemplo 00:33:47

para conseguir 00:33:48

este agujero 00:33:49

vale 00:33:50

porque si no 00:33:51

no se podría conseguir 00:33:52

de otra forma 00:33:53

entonces 00:33:54

básicamente 00:33:55

ahora 00:33:56

lo que tenemos 00:33:57

en este nivel 00:33:58

no sé 00:33:59

me vais siguiendo 00:34:00

hasta aquí 00:34:01

más o menos 00:34:02

vale 00:34:03

ahora vamos a ver 00:34:04

los inconvenientes 00:34:05

que van a surgir 00:34:06

en el 00:34:07

nivel 2 00:34:08

relacionado con esto 00:34:09

pero antes de llegar a eso 00:34:10

me interesa 00:34:11

que veamos 00:34:12

cómo 00:34:13

este nivel 00:34:14

y el reinicio 00:34:15

de nivel 00:34:16

también 00:34:17

cuando se cae 00:34:18

por el precipicio 00:34:19

hasta aquí más o menos 00:34:20

me vais siguiendo 00:34:21

vale 00:34:22

perdonad que a veces 00:34:23

es un poco enrevesado 00:34:24

porque 00:34:25

hay muchas veces 00:34:26

que se dice 00:34:27

collider 00:34:28

si no me preguntáis 00:34:29

por favor 00:34:30

vale 00:34:31

a ver 00:34:32

nada 00:34:33

aquí 00:34:34

en este nivel 00:34:35

que es diferente 00:34:36

al siguiente 00:34:37

vale 00:34:38

lo que queremos 00:34:39

y lo que está 00:34:40

especificado en la tarea 00:34:41

es 00:34:42

que si se cae 00:34:43

dentro 00:34:44

pues que 00:34:45

cambie de nivel 00:34:46

y si se cae 00:34:47

de la plataforma 00:34:48

que se reinicie el nivel 00:34:49

esto si lo analizamos 00:34:50

lo que significa es 00:34:51

que la tabla 00:34:52

en ningún momento 00:34:53

hay que moverla 00:34:54

la tabla es 00:34:55

un elemento estático 00:34:56

que 00:34:57

pues 00:34:58

va a estar ahí 00:34:59

que eso sí 00:35:00

tiene que proporcionar 00:35:01

una superficie física 00:35:02

a través de un collider 00:35:03

vale 00:35:04

que marque el límite físico 00:35:05

en el que 00:35:06

contra el que va a chocar la pelota 00:35:07

es decir 00:35:08

como un objeto 00:35:09

y otro 00:35:10

tienen que chocar 00:35:11

el límite físico 00:35:12

y otro 00:35:13

tiene que tener 00:35:14

algún collider 00:35:15

de un tipo 00:35:16

vale 00:35:17

y ojo 00:35:18

los colliders 00:35:19

ya se veía en el tema 00:35:20

tienen siempre la opción 00:35:21

de East Trigger 00:35:22

vale 00:35:23

atención 00:35:24

cuando cualquier collider 00:35:25

tiene el East Trigger 00:35:26

marcado 00:35:27

vale 00:35:28

yo cuando dé a play 00:35:29

vais a ver 00:35:30

que atraviesa 00:35:31

vale 00:35:32

y diréis 00:35:33

pero si tiene un collider 00:35:34

ojo 00:35:35

los triggers 00:35:36

trigger es la traducción 00:35:37

de disparador 00:35:38

vale 00:35:39

sirven para desencadenar 00:35:40

ahora vemos 00:35:41

los métodos 00:35:42

que pueden hacerlo 00:35:43

por ejemplo 00:35:44

en este momento 00:35:45

de curso 00:35:46

pero 00:35:47

si hay un East Trigger 00:35:48

este 00:35:49

los colliders 00:35:50

cuando tienen el East Trigger 00:35:51

no funcionan ya como 00:35:52

paredes 00:35:53

no funcionan ya 00:35:54

como elementos físicos 00:35:55

contra los que colisionar 00:35:56

funcionan como áreas 00:35:57

para desencadenar 00:35:58

por eso 00:35:59

y aquí 00:36:00

es el motivo 00:36:01

por el que está plantado así 00:36:02

igual que 00:36:03

el terreno 00:36:04

tiene 00:36:05

un collider 00:36:06

que no es trigger 00:36:07

es decir 00:36:08

sirve de límite físico 00:36:09

no tiene el East Trigger 00:36:10

vale 00:36:11

porque queremos que funcionen 00:36:12

como 00:36:13

superficies 00:36:14

la meta 00:36:15

este collider 00:36:16

a ver 00:36:17

que tengo aquí 00:36:18

vale 00:36:19

fijaos que está ahí metido 00:36:20

pero ese sí es trigger 00:36:21

porque es que la función 00:36:22

de esta caja 00:36:23

que he metido aquí 00:36:24

de este cubo 00:36:25

es que cuando se meta la pelota 00:36:26

y choque 00:36:27

vale 00:36:28

y ojo 00:36:29

que digo chocar 00:36:30

pero no es el mejor verbo 00:36:31

en cuanto toque este área 00:36:32

y se introduzca dentro del área 00:36:33

que desencadene una acción 00:36:34

pero 00:36:36

bueno 00:36:37

yo ya le he dicho que acción es 00:36:38

el nivel 00:36:39

pero realmente cuando se mete la bola 00:36:40

por aquí 00:36:41

no está chocando con ese elemento 00:36:42

se 00:36:43

chocará contra 00:36:44

el agujero 00:36:45

es decir 00:36:46

si yo desactivo este script 00:36:47

que es el que hace 00:36:48

que cuando toque 00:36:49

este 00:36:50

elemento 00:36:51

este área 00:36:52

que hemos definido 00:36:53

con un collider 00:36:54

se introduzca 00:36:55

vais a ver 00:36:56

y dejo ahí esa cámara 00:36:57

que la pelota 00:36:58

no va a desencadenar nada 00:36:59

pues porque no tengo por código 00:37:00

que desencadene nada 00:37:01

pero fijaos 00:37:02

que el trigger 00:37:03

joder 00:37:04

sí que está 00:37:05

a ver 00:37:06

go 00:37:07

esto es porque también lo tengo 00:37:08

en algún otro script 00:37:09

ya configurado 00:37:10

este todo 00:37:11

creo que va a ser 00:37:16

la propia bola 00:37:17

la que tiene un script 00:37:18

vale 00:37:19

eh 00:37:20

tendría que quitar cosas del script 00:37:21

verdad 00:37:23

y por qué me cambié de nivel 00:37:26

un segundín eh 00:37:29

entonces 00:37:31

tengo este terreno 00:37:32

y tengo 00:37:34

bueno 00:37:37

si no está funcionando 00:37:38

vale 00:37:39

vale voy a crear 00:37:40

bueno 00:37:41

de todos modos 00:37:42

no está funcionando 00:37:43

del todo 00:37:44

como quiero 00:37:45

porque 00:37:46

en principio 00:37:47

si desactivo el script 00:37:48

a ver un segundo 00:37:49

que estoy dando para atrás 00:37:50

tututu 00:37:51

la bola 00:37:52

el goal 00:37:53

cambio escena 00:37:54

go 00:37:55

a ver 00:37:56

un segundito 00:37:57

esto 00:37:58

esto 00:37:59

esto 00:38:00

esto 00:38:01

esto 00:38:02

esto 00:38:03

esto 00:38:04

esto 00:38:05

esto 00:38:06

esto 00:38:07

oh 00:38:08

qué 00:38:09

por qué no hace caso 00:38:15

no me cambia de nivel 00:38:16

vale 00:38:19

esto 00:38:20

es porque en el script 00:38:27

yo tengo preparado 00:38:29

que 00:38:30

en algún momento 00:38:31

cambiar 00:38:32

no me quiero liar mucho 00:38:33

con esto 00:38:34

porque no 00:38:35

es lo que me interesa 00:38:36

East Trigger 00:38:37

a ver, pero 00:38:40

no entiendo, a ver, espera, a ver si es que 00:38:41

no 00:38:44

jope, ¿y por qué? 00:38:44

un segundo, que igual está aquí, no 00:38:50

jope, pues 00:38:52

esto es rarísimo 00:38:57

a ver si es que no he guardado 00:39:00

algo y tengo que 00:39:02

volver a hacerlo 00:39:04

pero nada, eh 00:39:04

y me iba a cambiar de nivel 00:39:07

no sé 00:39:11

no debería, ¿vale? pero por defecto 00:39:12

joder, voy a 00:39:16

remover directa, es que no puede ser 00:39:17

remove 00:39:20

remove 00:39:23

es que quiero que veáis el ejemplo porque me 00:39:25

sirve, si no lo genero yo ahora 00:39:27

pero vaya, que es que este 00:39:29

es el más fácil ahora mismo para crearlo 00:39:31

vale, ahora 00:39:34

vale, ¿veis? 00:39:36

vale, ¿veis? 00:39:37

ahora no tengo ningún script que se ha quedado ahí como bloqueado 00:39:37

porque realmente lo está desactivando 00:39:40

y debería, pero veis que la bola 00:39:41

ahora mismo está dentro 00:39:43

de un collider, pero claro 00:39:45

como ese collider es un trigger 00:39:47

no tiene ya las propiedades 00:39:49

de colisión, ¿vale? entonces lo atraviesa 00:39:52

¿de qué sirve? 00:39:54

sirve pues para marcar zonas en las que 00:39:55

pase algo, pues oye, que cuando 00:39:57

pase por una puerta, pongo un área con 00:39:59

un isTrigger, ¿vale? marcado con ese collider 00:40:01

y cuando pase la puerta, pues que empiece a sonar 00:40:03

una alarma, o que 00:40:05

cambie de nivel, como sucede aquí 00:40:07

ese tipo de cosas, ¿vale? entonces hay que distinguir 00:40:09

entre los dos usos que tiene 00:40:11

un collider, yo no sé por qué funciona 00:40:13

si lo está desactivando, pero bueno, se habría quedado 00:40:15

ahí congelado, ¿vale? no sé si 00:40:17

entendéis, esto lo iremos practicando 00:40:19

en más temas, de todos modos, y ahora 00:40:21

lo vamos a ver más, pero 00:40:23

sobre todo seguidme hasta ahí, hasta ese momento 00:40:24

entonces, cuando 00:40:27

más o menos sí, ¿vale? 00:40:29

lo importante es eso, distinguir que hay colliders 00:40:31

que no son trigger 00:40:33

que son por defecto, que sirven como 00:40:35

condicionadores, realmente, y luego 00:40:37

están los que desencadenan acciones 00:40:39

¿vale? por ejemplo 00:40:40

una pregunta, cuando 00:40:43

es trigger, por ejemplo 00:40:45

cuando lo metes en 00:40:46

con el código, lo haces 00:40:48

como pones trigger 00:40:51

como trigger, y cuando no, lo pones como 00:40:53

collider, son diferentes códigos 00:40:55

me parece, ¿no? claro, hay dos 00:40:56

métodos, ¿vale? que son los de la familia 00:40:59

onTrigger y los de la familia onCollision 00:41:01

que están relacionados exactamente con esto 00:41:03

voy a explicar 00:41:06

segundo cómo funciona, por ejemplo, este 00:41:07

trigger, ¿vale? para hacer una introducción 00:41:09

y luego vemos la diferencia, ¿vale? 00:41:10

cuando, para hacer que se reinicie 00:41:13

el nivel, lo que 00:41:15

lo suyo, ¿vale? lo suyo sería crear 00:41:16

un GameObject que 00:41:19

realmente lo único que tiene en sí mismo 00:41:21

es un BoxCollider que es un trigger 00:41:23

¿qué significa? que si yo creo 00:41:25

un BoxCollider que abarca toda la zona 00:41:27

inferior, en cuanto la bola se caiga 00:41:29

¿vale? lo vemos aquí, en cuanto 00:41:31

la bola se caiga y toque ese 00:41:33

collider, que no sirve de superficie 00:41:34

casi no de desencadenador 00:41:37

vais a ver que yo cuando veáis 00:41:39

que se cae la bola, en cuanto toca ese collider 00:41:41

yo he hecho un código 00:41:43

he incorporado un código 00:41:45

que ahora vemos, que lo que hará es 00:41:46

detectar que ha habido esa colisión 00:41:49

o mejor dicho, ese trigger 00:41:51

¿vale? y dispara la acción 00:41:53

de reiniciar este mismo nivel en el que 00:41:55

estamos, ¿sí? 00:41:57

que no es lo mismo que 00:41:59

lo que está sucediendo en todo momento 00:42:01

de que la bola, lo digo porque 00:42:03

en alguna de las dudas 00:42:05

que me pusisteis, era 00:42:07

en todo momento se está reiniciando el nivel 00:42:09

claro, pues porque, por ejemplo 00:42:11

si hubiéramos puesto el trigger 00:42:13

relacionado con este collider 00:42:15

en cuanto tocara este collider 00:42:17

pues sería este el que desencadenaría que en todo momento 00:42:18

se reinicie, ¿vale? entonces 00:42:21

cuando tenemos este objeto precipicio 00:42:23

por ejemplo, ¿vale? de hecho 00:42:25

lo voy a crear yo de cero para que veáis 00:42:27

como lo haría, ¿vale? cuando creamos 00:42:29

un empty object 00:42:31

y decimos, este es el precipicio 00:42:32

lo voy a llamar 00:42:34

o el 00:42:36

¿cómo se llama? el umbral 00:42:37

no sé, el reinicio 00:42:39

nivel, ¿vale? yo voy a hacer aquí un área 00:42:41

que lo que hace es reiniciar el nivel 00:42:43

yo ese objeto no voy a querer en ningún momento 00:42:44

que muestre nada visual 00:42:47

va a servir solo como área de desencadenar 00:42:48

cosas, ¿vale? por eso aquí no vais a ver 00:42:51

en ningún momento un mesh renderer 00:42:53

por ejemplo si hubiera una geometría 00:42:54

ni un 00:42:56

nada relacionado eso con 00:42:57

a ver, por ejemplo la bola 00:43:01

pues es un mesh renderer, la propia geometría 00:43:02

que es este mesh filter 00:43:05

¿vale? 00:43:07

se pueden crear, como sucede 00:43:07

con los empty objects 00:43:09

objetos que solo tienen una posición 00:43:11

y nada físico, ¿vale? ojo 00:43:13

cuando creamos un nuevo empty object 00:43:15

lo normal es resetearlo porque 00:43:16

a no ser que cambiamos una configuración 00:43:18

lo genera en el centro 00:43:21

del visor donde estemos, si estamos aquí 00:43:23

lo genera aquí, entonces vais a ver que ya 00:43:25

a veces puede tener unas coordenadas por defecto 00:43:27

lo reiniciamos y ahí estamos otra vez en el 00:43:29

punto de origen, ¿vale? y yo como quiero 00:43:31

generar ese precipicio 00:43:33

lo que hago es bajarlo porque quiero 00:43:34

que esté abajo y decirle, ¿vale? voy a generar 00:43:37

un área que dispare algo, ¿vale? esto ya 00:43:39

más allá del código es pensar qué queremos hacer 00:43:42

¿no? y decimos, queremos que cuando caiga la pelota 00:43:44

pues haya un área 00:43:47

aquí sí que nos da igual que sea la forma 00:43:49

primitiva o una muy vasta 00:43:50

porque lo que queremos es que cuando caiga de aquí 00:43:52

haya un área que detecte 00:43:54

que la bola ha tocado esa área, ¿no? entonces 00:43:56

lo que vamos a hacer es 00:43:58

para que si la pelota, igual 00:44:00

si la pelota sale con mucha fuerza pues que no 00:44:01

se escape 00:44:04

un área que siempre que se caiga la pelota 00:44:05

tenga por narices que tocar 00:44:07

este box collider, ¿vale? 00:44:08

y por defecto vais a ver que si yo hago eso 00:44:11

cuando yo me caigo de aquí 00:44:13

empieza a caerse la pelota 00:44:15

empieza a caerse y se queda ahí flotando 00:44:17

porque está colisionando que aunque 00:44:18

no se vea una forma física 00:44:21

¿vale? aquí lo que vamos a querer no es que 00:44:22

choque contra esto, sino que 00:44:25

lo pueda atravesar incluso y 00:44:26

desencadene otra acción, ¿vale? 00:44:29

lo que pasa es que aquí surgen 00:44:31

dos posibilidades, una 00:44:33

que desencadene la acción 00:44:34

en cuanto toca 00:44:37

este área 00:44:38

pues que desencadene una acción 00:44:41

¿vale? y como no es un trigger 00:44:42

al caer aquí, se queda aquí 00:44:44

pero podemos definir con un 00:44:46

collision enter, un collision stay 00:44:49

diferentes, las diferentes 00:44:50

acepciones que tiene esa familia 00:44:53

el collision, el método 00:44:54

con collision lo que sirve es para que 00:44:57

en cuanto un objeto toque a otro 00:44:59

que es un colisionador, es decir, no un trigger 00:45:00

no tiene la marca de la casilla de isTrigger 00:45:02

que desencadene algo, ¿vale? 00:45:04

por 00:45:07

en cambio, si nosotros lo que estamos 00:45:08

generando es un trigger 00:45:11

de detección, ¿vale? lo que vamos a definir 00:45:12

con los métodos de onTrigger 00:45:15

es que en cuanto atraviese esta 00:45:17

plataforma, y veis que sigue bajando, pero 00:45:19

lo ha atravesado en algún momento, nosotros 00:45:21

por código podamos definir 00:45:23

qué acción se desencadena cuando 00:45:25

sucede eso, ¿vale? entonces 00:45:26

vamos a ver las dos formas 00:45:29

de hacerlo, voy a dejar el collider de forma que 00:45:30

sea un colisionador, ¿no? y entonces 00:45:32

cuando yo creo un script de 00:45:34

reinicioNivel 00:45:37

¿vale? lo genero, porque 00:45:39

la función que va a tener es 00:45:41

asociada a este gameObject 00:45:42

de reinicio es, pues que cuando llegue 00:45:45

ahí, podamos desencadenar, pues por ejemplo 00:45:47

este reinicioNivel, lo que vamos a hacer es 00:45:49

voy a abrir ese script 00:45:51

que acabo de crear, ¿vale? este está por 00:45:53

defecto, ¿lo veis? entiendo 00:45:55

hola, por cierto, que creo que ha llegado alguien 00:45:56

más a la tutoría 00:45:59

¿vale? 00:46:01

tenemos este reinicioNivel, ¿vale? 00:46:03

y voy a ir a lo más básico 00:46:05

que nosotros aquí abajo, fuera del 00:46:07

start y del update 00:46:09

el que un evento 00:46:10

de colisión o de trigger se desencadene 00:46:13

realmente no está asociado con 00:46:16

un momento de ejecución del juego 00:46:17

¿no? no es ni al start, ni en 00:46:19

cada fotograma, sino que queremos que se ejecute 00:46:21

en el momento que suceda 00:46:24

esa colisión, por eso hay que pensar 00:46:25

que igual que podíamos crear 00:46:27

el fixUpdate 00:46:30

¿vale? y os hablé también 00:46:32

el otro día del lateUpdate, que son momentos 00:46:33

de ejecución en el ciclo de ejecución 00:46:35

que os mostré un esquema 00:46:37

el otro día, ¿vale? también se puede 00:46:40

por ejemplo, meter uno 00:46:41

de la familia onCollisionEnter 00:46:43

¿vale? y fijaos que cuando empezáis 00:46:45

a escribir onCollision 00:46:47

vuelvo a hacerlo, el IntelliSense, esta ayuda 00:46:49

que tenemos, si elegís una de las 00:46:51

opciones, ya os completa, digamos 00:46:53

el método por 00:46:55

completo, ¿vale? os lo escribe 00:46:57

no tenéis que saberlo todo de memoria 00:46:59

porque si decís un onCollisionExit 00:47:01

le dais doble clic y ya lo 00:47:04

prepara, ¿vale? esta familia 00:47:05

de onCollisionEnter, que tienen el enter 00:47:07

el stay y el exit, muy similares 00:47:09

a cuando hacíamos los inputs 00:47:12

este input down, getKeyButton 00:47:13

down, getKeyButton 00:47:16

up, etcétera 00:47:17

es que detecte 00:47:19

que en cuanto haya una colisión aquí 00:47:21

¿vale? sea en el momento en el que colisiona 00:47:23

en todo momento 00:47:26

con el stay, en todo momento 00:47:27

mientras se está colisionando 00:47:29

¿vale? stay 00:47:31

sería otro 00:47:33

¿vale? 00:47:34

el exit, vamos a hacer un ejemplo de cada uno 00:47:35

el onCollisionEnter 00:47:38

es en cuanto un objeto 00:47:40

con un colisionador toque a este 00:47:41

¿vale? que se desencadene algo 00:47:44

y para ver que se desencadena, por ejemplo 00:47:46

vamos a poner un debug log 00:47:48

que sea 00:47:49

han colisionado dos objetos 00:47:50

por poner algo, ¿vale? 00:47:56

ahora mismo estamos diciendo que cuanto 00:47:58

este 00:47:59

el gameObject que tenga este script 00:48:00

¿vale? 00:48:04

reciba una colisión 00:48:05

¿vale? pues que lance esta frase 00:48:07

entonces, si nos vamos fijando en la consola 00:48:09

voy a limpiarla 00:48:11

cuando yo ejecuto el juego 00:48:13

aunque aquí ha habido una colisión no ocurre nada 00:48:15

¿vale? pero yo voy moviendo la pelota 00:48:17

y en cuanto, a ver, marco aquí esto 00:48:19

en cuanto toque la colisión 00:48:21

en cuanto toque un objeto con otro, colisionan 00:48:23

y dice, eh, han colisionado dos objetos 00:48:25

¿vale? 00:48:27

con esto veis que la pelota 00:48:29

no está atravesando el objeto 00:48:31

pero sí que ha detectado la colisión, entonces 00:48:33

al entrar en el primer momento 00:48:35

que se da esa colisión 00:48:37

pues aquí nosotros podemos por código 00:48:39

poner todo lo que queramos 00:48:41

aquí he puesto un debug log, pero también podremos decir 00:48:43

que la pelota, por ejemplo 00:48:45

reciba una fuerza inversa hacia arriba 00:48:47

¿vale? entonces 00:48:49

ese es, por ejemplo 00:48:51

es una explicación de long collision 00:48:53

que queremos que en todo 00:48:55

momento que la pelota, en este caso 00:48:57

o que existe una colisión 00:48:59

en todo momento que se estén colisionando esos dos objetos 00:49:01

no sólo al empezar esa colisión 00:49:03

y por eso sólo lanza el mensaje una vez 00:49:05

sino que en cada fotograma 00:49:07

que se estén tocando los dos objetos 00:49:09

quiero que ponga 00:49:11

debug log 00:49:13

quiero que ponga 00:49:15

la pelota 00:49:17

o algo 00:49:19

está colisionando 00:49:21

eh 00:49:23

todo el rato, yo que sé 00:49:25

para distinguirlo, bueno, el mensaje es 00:49:27

parecido al de antes 00:49:29

pero vais a ver que al ejecutarlo 00:49:31

ya no sólo se lanza el mensaje una vez 00:49:33

cuando toca, todo momento 00:49:35

que se estén tocando 00:49:37

se está ejecutando ese 00:49:39

a ver un segundo, porque no sé si es que no he guardado 00:49:41

vale, perdonad, que es que no he guardado 00:49:43

por eso no se está ejecutando bien 00:49:45

aquí le doy 00:49:47

limpio la 00:49:49

consola 00:49:51

y ahora sí que debería que 00:49:53

al meterme 00:49:55

veis que ahora salen muchos mensajes 00:49:57

cada fotograma que se estén tocando 00:49:59

está existiendo esa colisión 00:50:01

y estoy permaneciendo en esa colisión 00:50:03

y por tanto sigue lanzando mensajes 00:50:05

pero mirad, voy a sacar la bola 00:50:07

me voy a ir al límite de este 00:50:09

área que he definido, se cae otra vez 00:50:11

y fijaos que ya como no están 00:50:13

tocándose, pues ya no hay 00:50:15

más mensajes, que si consiguiera 00:50:17

otra vez poner la pelota tocando este objeto 00:50:19

seguiría en el tiempo que estén tocándose 00:50:21

cada fotograma haría una 00:50:23

ejecución de lo que pongamos dentro de ese método 00:50:25

y luego por último 00:50:27

el onCollisionExit 00:50:29

lo que hace es 00:50:31

que en cuanto la pelota deje de colisionar con otra 00:50:33

veis que ahora 00:50:35

yo cuando colisiono 00:50:37

no pasa nada, ha entrado 00:50:39

ahora estamos en el CollisionEnter 00:50:41

ahora todo este rato que no ha sido 00:50:43

el primer impacto 00:50:45

estamos en el onCollisionStay 00:50:47

y ahora cuando me salga vais a ver que solo 00:50:49

se va a lanzar un mensaje cuando deje de tocar 00:50:51

que es 00:50:53

algo está colisionando, porque es la salida 00:50:55

de la colisión 00:50:57

lo que hacen los onCollision 00:50:59

en cualquiera de sus variantes es 00:51:01

definir 00:51:03

que cuando dos objetos colisionen 00:51:05

o mejor dicho, cuando un objeto 00:51:07

como es este el que tiene el script 00:51:09

cuando un objeto, ahora mismo cualquiera 00:51:11

podría ser la bola o podría ser que la plataforma 00:51:13

se cayera también, cuando la tocara 00:51:15

lanzaría el mensaje, pues diría 00:51:17

aquí ha habido una colisión 00:51:19

vale 00:51:21

el Trigger en cambio 00:51:23

es el mismo concepto 00:51:25

solo que con objetos que son triggers 00:51:27

y por tanto sirven para que se puedan 00:51:29

atravesar, os vuelvo a poner el ejemplo de antes 00:51:31

imaginaos que tenéis una puerta 00:51:33

y tenéis que pasar por la puerta 00:51:35

pero al pasar por la puerta queréis desencadenar 00:51:37

que se encienda una luz, automáticamente 00:51:39

como si lo hubiera tocado un sensor 00:51:41

tu ahí no quieres que el Collider sea algo 00:51:43

físico, pero quieres que esa área 00:51:45

detecte que un personaje está atravesando la puerta 00:51:47

en ese caso pondríamos un Trigger 00:51:49

en este caso pues lo voy a poner 00:51:51

el Trigger marcado 00:51:53

vale, pues aquí 00:51:55

lo que habría que hacer es 00:51:57

borro 00:51:59

esto que tengo ahora mismo de onCollision 00:52:01

y voy a generar otro 00:52:03

método, nuevamente 00:52:05

fuera de las ejecuciones, de los tiempos de ejecución 00:52:07

porque es un propio momento 00:52:09

de ejecución basado en 00:52:11

que haya ese Trigger y veréis que hay 00:52:13

también onTrigger, enter, exit, stay 00:52:15

es exactamente lo mismo solo que 00:52:17

relacionado, y cuando le doble clic 00:52:19

lo rellena entero 00:52:21

relacionado con los Triggers 00:52:23

pues aquí el exit 00:52:25

vamos a poner que lo que muestra es 00:52:27

debug log 00:52:29

me han 00:52:33

atravesado 00:52:35

y lo mismo, yo cuando 00:52:37

la pelota ahora 00:52:39

juegue, me muevo 00:52:41

y vais a ver que la pelota ya no se queda ahí 00:52:43

porque es un Trigger 00:52:45

uno de los dos elementos, uno es como 00:52:47

incorpóreo, pero al atravesarlo 00:52:49

sí que lo ha atravesado 00:52:51

por dejarlo ya un poco más 00:52:53

zanjado y ver todas las posibilidades 00:52:55

si yo a esto le pongo el onTriggerStay 00:52:57

vais a ver que 00:52:59

el tiempo, que tampoco va a ser muy largo 00:53:01

que está atravesando ese 00:53:03

precipicio, este 00:53:05

área, vais a ver 00:53:07

que en todo momento 00:53:09

está soltando el mensaje, por eso va a haber 00:53:11

más de uno, y luego ya 00:53:13

cuando ha salido por debajo 00:53:15

ha habido 8 momentos que 00:53:17

ha estado dentro la pelota 00:53:19

y con el onTriggerExit 00:53:21

sería un poco lo mismo, pero 00:53:23

cuando detectará que deja de estar dentro 00:53:25

de ese área, no sé si 00:53:27

hasta aquí entiendo que me vais entendiendo 00:53:29

y esto parece un poco 00:53:31

lo mismo, pero ya veis que el método cambia 00:53:33

pero 00:53:35

en ciertas ocasiones nos puede interesar uno u otro 00:53:37

por ejemplo eso, aquí porque he 00:53:39

cambiado de nivel y no se ve, pero yo realmente 00:53:41

ese límite que estoy metiendo ahí 00:53:43

no quiero que sea corpóreo, por tanto será 00:53:45

onTrigger lo que pongo, que quiero 00:53:47

que sea que en cuanto la 00:53:49

mira, de hecho vamos a hacer un ejemplo 00:53:51

voy a hacer 00:53:53

que el 00:53:55

terreno, que tiene 00:53:57

un MeshCollider, que es colisionador 00:53:59

cuando la pelota 00:54:01

toque ese terreno, reciba un impulso que le 00:54:03

lance para arriba, pues vamos a hacerlo así 00:54:05

un poco rápido, yo lo que voy a hacer 00:54:07

voy a hacer otro script diferente 00:54:09

en paralelo 00:54:11

simplemente por el ejemplo, que sería 00:54:13

un poco lo que he creado 00:54:15

lo que se ha creado en el nivel 4 este de pinball 00:54:17

que os he enseñado, a ver 00:54:19

fuerza 00:54:21

choque, yo que sé 00:54:23

y se lo aplico a 00:54:25

a la superficie, al terreno, a la plataforma 00:54:27

esta va a 00:54:29

reaccionar aquí, o a la pelota 00:54:31

se puede poner a cualquiera de los dos, porque al final 00:54:33

lo que va a aplicar 00:54:35

lo voy a poner mejor a la bola 00:54:39

porque la que va a recibir la bola 00:54:41

la fuerza es la bola, entonces es más fácil 00:54:43

definirlo 00:54:45

pongo otro script que es fuerza choque 00:54:47

se puede poner más de un script 00:54:49

se irán sumando las 00:54:51

lo que hayamos indicado 00:54:53

en cada uno, y si yo ahora en fuerza choque 00:54:55

lo que le digo es 00:54:57

lo que voy a decirle es 00:54:59

oye, ojo 00:55:01

cuando haya un OnCollision 00:55:03

Enter 00:55:05

lo que voy a hacer es añadirle una fuerza hacia arriba 00:55:07

y me meto en otro 00:55:09

ámbito ahora mismo 00:55:11

vamos a irlo completando, pero otro ámbito 00:55:13

lo que vamos a querer hacer es que esta bola 00:55:15

mediante su RigidBody 00:55:17

y ojo, el RigidBody 00:55:19

hago un pequeño repaso de que es 00:55:21

el RigidBody es 00:55:23

el componente que activa 00:55:25

el comportamiento físico 00:55:27

igual que los Colliders sirven para marcar 00:55:29

límites o marcar áreas que desencadenen 00:55:31

eventos o código 00:55:33

en ciertos momentos 00:55:35

el RigidBody hasta que no se pone 00:55:37

no, por ejemplo, existe ninguna 00:55:39

física, es decir, si yo tengo 00:55:41

el RigidBody aplicado a la bola 00:55:43

la bola se mueve por las leyes de la física 00:55:45

y tiene esa gravedad, porque 00:55:47

por defecto tiene este parámetro de usar gravedad 00:55:49

si yo lo quitara 00:55:51

por mucho que tengan Collider 00:55:53

los dos, pues nada, cae 00:55:55

porque no hay ningún objeto que tenga un comportamiento 00:55:57

físico, por eso el RigidBody 00:55:59

lo debería tener 00:56:01

como mínimo siempre 00:56:03

el objeto que se mueve 00:56:05

o que tiene que ver afectado por la gravedad 00:56:07

lo pueden tener también todos los objetos 00:56:09

pero para que exista una colisión 00:56:11

tiene que haber un elemento 00:56:13

que se esté moviendo, sino nunca chocan 00:56:15

por otro lado, entonces 00:56:17

vuelvo a la bola a ponerle 00:56:19

el RigidBody, que lo había aplicado 00:56:21

y ahora la bola 00:56:23

se somete a la fuerza de la gravedad 00:56:25

con, esto también está 00:56:27

en el mapa, con la masa 00:56:29

con la resistencia al aire que definamos aquí 00:56:31

ahora mismo no es lo que más me interesa 00:56:33

pero el comportamiento físico 00:56:35

de una bola no es el mismo 00:56:37

si la resistencia al aire es muy alta 00:56:39

que vais a ver que se va a ir cayendo 00:56:41

un poco más despacio que si no lo es 00:56:43

o si la masa es 00:56:45

de 100 kilos en vez de 6 00:56:47

vais a ver que cambia 00:56:49

ahora 00:56:51

aunque cuando se da play tarda un poco 00:56:53

en arrancar 00:56:55

la caída de la bola es 00:56:57

un poco más rápida porque el peso ha cambiado 00:56:59

pero lo que me interesa es 00:57:01

que cuando 00:57:03

esto por defecto viene aquí 00:57:05

escondido 00:57:07

el RigidBody también tiene información relacionada 00:57:09

con las fuerzas 00:57:11

vale, vais a ver que en el tiempo 00:57:13

que se está cayendo la bola sin yo tocar ninguna tecla 00:57:15

ahí ha habido una variación de números 00:57:17

vale, y hay 00:57:19

una dirección de ejes 00:57:21

que digamos que más allá de las fuerzas 00:57:23

que vayamos aportando 00:57:25

nos dice si la pelota yo la estoy moviendo hacia la izquierda 00:57:27

o a la derecha, vale 00:57:29

voy a darle hacia adelante y suelto 00:57:31

y por la propia inercia la pelota va teniendo 00:57:33

el RigidBody que cada vez se irá reduciendo 00:57:35

aquí por ejemplo no para nunca 00:57:37

porque la inercia vale 00:57:39

le acabo de dar un toque 00:57:41

y he soltado el teclado al control 00:57:43

la pelota sigue rodando porque no hay fricción 00:57:45

vale, este material de madera 00:57:47

pues por ejemplo 00:57:49

volviendo un poco a lo de antes 00:57:51

la plataforma del terreno 00:57:53

el material que tiene de madera 00:57:55

pues tiene una fricción 00:57:57

bastante reducida 00:57:59

o la bola, vamos a ver el material 00:58:01

de la bola, el material físico 00:58:03

lo tengo 00:58:05

a ver 00:58:07

aquí está, tengo la madera 00:58:09

y la 00:58:11

y la 00:58:13

el acero de la pelota 00:58:15

vale, si yo digo que la fricción 00:58:17

de ambos elementos 00:58:19

sea bastante elevada 00:58:21

vale 00:58:23

cuando le de al play y se esté moviendo el objeto 00:58:25

y esté en movimiento 00:58:27

vais a ver que ya sí que va a ir frenando 00:58:29

o debería, a ver 00:58:31

también está esta opción 00:58:33

es que para empezar, a ver, tengo aplicado 00:58:35

acero, vale, y en el terreno tengo 00:58:37

madera, vale 00:58:39

en madera tengo una fricción alta 00:58:41

y en esta tengo 00:58:43

una fricción alta, luego 00:58:45

esto se ve en el tema, hay que 00:58:47

ir aplicando como se combinan 00:58:49

los elementos entre sí, entonces 00:58:51

no es lo mismo 00:58:53

ahora debería ir frenando más, vale 00:58:55

que se combinen en el máximo 00:58:57

que irá sumando más 00:58:59

a ver porque no 00:59:01

voy gastando 00:59:03

creo que es porque no he 00:59:05

guardado la partida 00:59:07

a ver 00:59:09

esta fuerza 00:59:11

se está haciendo de manera continua 00:59:13

y a ver, un segundín 00:59:15

si voy a la bola, simplemente por ver 00:59:17

el funcionamiento, vale 00:59:19

ah bueno 00:59:21

claro, ya también 00:59:23

ahora os digo otro elemento 00:59:25

que es lo que está haciendo, tenemos en cuenta 00:59:27

que la bola, el comportamiento físico no tiene 00:59:29

ninguna resistencia al aire, entonces es como si 00:59:31

estuviera flotando en el espacio 00:59:33

es como la gravedad, aparte de la propia fricción 00:59:35

vale, es este 00:59:37

drag el que está definiendo 00:59:39

que siga arrastrándose o no en el 00:59:41

espacio, si no hay nada que lo detiene 00:59:43

y aquí casi que estaba flotando 00:59:45

empieza a avanzar y nada lo detiene 00:59:47

es el drag el que está haciendo esa resistencia 00:59:49

ahora sí que frena 00:59:51

¿alguien ha dicho, ha soltado 00:59:53

algún, ha pedido 00:59:55

una pregunta 00:59:57

materiales, si cambian los materiales 00:59:59

las características, por ejemplo 01:00:01

el rozamiento, la resistencia, lo que sea 01:00:03

automáticamente te lo cambia donde lo tengas 01:00:05

ya aplicado, o lo tienes que volver a aplicar 01:00:07

lo suyo es que guardéis la escena cuando lo hagáis 01:00:09

pero sí, sí debería aplicarlo 01:00:11

sí debería, vale, lo que pasa 01:00:13

es que ahora 01:00:15

igual que antes cuando botaba 01:00:17

la pelota, botaba 01:00:19

según cambiaba aquí, vale, fijaos 01:00:21

es que la fricción no estaba funcionando porque no tenía ninguna 01:00:23

resistencia al aire, entonces se estaba 01:00:25

moviendo continuamente en el 01:00:27

espacio, digamos, pero 01:00:29

si voy a los materiales, fijaos 01:00:31

tengo aquí la bola, y la bola 01:00:33

le digo que es de la cero 01:00:35

tenga mucho bote 01:00:37

si le doy al play, vamos 01:00:39

si lo cambio aquí en el material, vale, y le doy al play 01:00:41

vais a ver que ya tiene ese bote aplicado 01:00:43

entonces sí se aplica directamente 01:00:45

si yo por ejemplo digo cero, vais a ver que no 01:00:47

vale 01:00:49

entonces sí, se cambia directamente 01:00:51

si cambias el material físico 01:00:53

ya afecta a todos los materiales que lo tengan 01:00:55

aplicados, a todos los colliders que tengan 01:00:57

aplicados ese material físico, sí 01:00:59

sí 01:01:01

a ver, es que como no veo a veces 01:01:03

vale, sí, me 01:01:05

queda resuelta 01:01:07

la duda 01:01:09

sí, vale, perfecto 01:01:11

entonces, vamos a seguir con esto 01:01:13

lo que hay que pensar 01:01:15

cuando añadimos fuerzas, vale 01:01:17

es que a la que estamos añadiendole 01:01:19

fuerzas en todo momento es a este cuerpo de simulación 01:01:21

física, este rigidbody, por eso 01:01:23

cuando afectemos por código 01:01:25

a algún elemento que 01:01:27

aplique fuerzas a nivel físico 01:01:29

tendremos que afectar a este componente 01:01:31

porque lo que básicamente vamos a hacer 01:01:33

es darle una velocidad a una fuerza 01:01:35

en un ángulo de velocidad también 01:01:37

vale, no es 01:01:39

esto, a lo mejor es un poco enrevesado 01:01:41

pero vamos a ello 01:01:43

básicamente lo que estamos intentando hacer 01:01:45

es que cuando la pelota 01:01:47

a ver 01:01:49

y la tengo aquí 01:01:51

la fuerza de choque, aquí está, no sé 01:01:53

porque no se está viendo, la tengo aquí oculta 01:01:55

debe ser, vale, la fuerza de choque 01:01:57

vale, tengo aquí un script 01:01:59

que ahora lo que yo meta aquí va a funcionar 01:02:01

no, entonces, por ejemplo 01:02:03

para hacer la prueba, siempre las pruebas, los debug logs 01:02:05

vienen perfectos 01:02:07

la pelota 01:02:13

se ha posado, vale 01:02:15

y ahora cuando guardo y le doy aquí a la ejecución 01:02:17

cuando choque 01:02:19

la pelota se ha posado, y solo una vez 01:02:21

porque es una enter, vale 01:02:23

entonces, ahora lo que vamos a hacer, ya que sabemos 01:02:25

que está funcionando este script, es 01:02:27

aplicar una fuerza al 01:02:29

rigidbody, vale 01:02:31

para que lo empuje hacia otro lado, vale 01:02:33

que esto entiendo que ya 01:02:35

cuando habéis empezado con la práctica 01:02:37

habréis hecho algo similar, no 01:02:39

recordad que cuando declaramos una variable 01:02:41

como un float o un 01:02:43

int o un booleano, lo primero que se ponía era 01:02:45

el tipo de variable 01:02:47

en este caso, números decimales 01:02:49

y esto, aquí se pone el 01:02:51

el 01:02:53

nombre de esa variable, vale 01:02:55

pero ya os adelanté en algún momento que 01:02:57

el tipo de variable también puede ser o puede 01:02:59

coincidir con el nombre de los componentes 01:03:01

esto si recordáis 01:03:03

hicimos alguna prueba que es pues 01:03:05

el rigidbody tiene una especie de contenedor 01:03:07

vale, porque es una clase 01:03:09

en sí misma, vale, esta terminología 01:03:11

no quiero meterme mucho porque es 01:03:13

más enrevesado que entenderlo así 01:03:15

como que las variables 01:03:17

también pueden ser cajas 01:03:19

este ejemplo de las cajas, que albergue 01:03:21

una digamos 01:03:23

una referencia a un componente 01:03:25

entonces yo voy a poner este rigidbody 01:03:27

y le voy a llamar 01:03:29

por convención muchas veces se pone esto de rb 01:03:31

de rb, de rigidbody 01:03:33

pero lo de siempre, este es el nombre 01:03:35

se podría llamar también 01:03:37

aplicafuerzas 01:03:39

lo que sea, vale, esto es un nombre 01:03:41

para luego referenciarlo 01:03:43

y en este rigidbody, en esta caja que hemos preparado aquí 01:03:45

que hemos declarado, vale 01:03:47

cuando arranque el script 01:03:49

ahora mismo tenemos una caja que sabemos que 01:03:51

puede contener aquí un rigidbody 01:03:53

pero tenemos que indicar por código 01:03:55

que lo que vayamos a hacer sobre esta variable 01:03:57

sea sobre este rigidbody 01:03:59

aplicado 01:04:01

que está dentro 01:04:03

del objeto concreto 01:04:05

es decir 01:04:07

voy a explicar 01:04:09

voy a escribir primero la línea 01:04:11

y luego la vemos en detalle 01:04:13

esta variable 01:04:15

al lanzar el script en el start 01:04:17

vamos a decirle que 01:04:19

guarde dentro un componente 01:04:21

o que coja lo relativo a un componente 01:04:23

que también es de tipo 01:04:25

rigidbody 01:04:27

esto las primeras veces que se hace es complicado 01:04:29

es muy importante 01:04:31

no es aplicar fuerzas 01:04:33

es muy importante entenderlo 01:04:35

aquí hemos generado una caja 01:04:37

que se puede dirigir a lo que tenga 01:04:39

un componente rigidbody 01:04:41

esté en el game object que esté 01:04:43

es decir, es una clase que está ahí configurada 01:04:45

para 01:04:47

tocar 01:04:49

para poder aplicar 01:04:51

todo lo relativo a rigidbody 01:04:53

pero hasta que no le decimos 01:04:55

que toque el rigidbody 01:04:57

que guarde el rigidbody que está aplicado en este objeto 01:04:59

el script fuerza choque 01:05:01

está en este objeto 01:05:03

lo que va a hacer aquí es 01:05:05

aquí tenemos un código que lo que le va a decir 01:05:07

es, oye, búscame o coge 01:05:09

el componente rigidbody que haya en este objeto 01:05:11

más adelante 01:05:13

se va a poder decir, oye 01:05:15

quiero que me cojas 01:05:17

por ejemplo 01:05:19

a ver 01:05:21

esto lo hago de ejemplo, es más avanzado 01:05:23

imaginaos que tengo otro objeto, lo creo muy rápido 01:05:25

un cubo 01:05:27

que también tenga un rigidbody 01:05:29

a ver 01:05:31

el cubo 01:05:33

y aquí hay un cubo también que tiene 01:05:35

y de hecho, vamos a hacer el ejemplo bien hecho 01:05:37

y así también lo explico 01:05:39

dejo ahí el cubo 01:05:41

de este cubo aquí 01:05:43

lo voy a hacer más pequeño 01:05:45

simplemente para el ejemplo 01:05:47

y 01:05:49

lo pongo aquí 01:05:51

por defecto las formas primitivas 01:05:53

ya tienen su collider 01:05:55

lo que no va a ocurrir es que caiga 01:05:57

por el efecto de la gravedad dado que 01:05:59

le hemos puesto un rigidbody 01:06:01

le damos a rigidbody y ahora con su masa 01:06:03

etcétera, bueno, la dejo por defecto 01:06:05

ya caen los dos objetos y se quedan ahí 01:06:07

y de hecho, mirad que yo la bola 01:06:09

si choco contra ese objeto lo empuja 01:06:11

porque tiene comportamiento 01:06:13

físico 01:06:15

y fijaos que reacciona 01:06:17

y bueno, mirad que siempre 01:06:19

que la pelota toca un collider 01:06:21

como teníamos ese onCollisionEnter 01:06:23

desencadena un mensaje, cada vez que choco 01:06:25

imaginaos 01:06:27

en vez de poner un debug log quito vida 01:06:29

pues menos 20 cada vez que choco 01:06:31

vale, lo que me importa ahora mismo 01:06:33

es que yo 01:06:35

esto es para explicar el que es componer 01:06:37

que es algo muy interesante 01:06:39

ahora mismo cuando choque la pelota 01:06:41

le voy a poner 01:06:43

cuando hay una colisión 01:06:45

voy a hacer que aplicar fuerzas 01:06:47

que es 01:06:49

ese componente que está dentro del mismo objeto 01:06:51

que está aplicado 01:06:53

a la bola 01:06:55

en ese caso, le voy a aplicar una fuerza 01:06:57

con 01:06:59

uno de los métodos 01:07:01

de RigidBody 01:07:03

vale, esto 01:07:05

porque ha sido hasta este punto 01:07:07

para que nosotros digamos podamos lanzar 01:07:09

un AddForce por ejemplo 01:07:11

yo aunque aquí empiece a escribir Add 01:07:13

no sale nada 01:07:15

no existe este método en sí mismo 01:07:17

es un método que está asociado siempre 01:07:19

a un RigidBody 01:07:21

entonces hasta que no tenemos esta caja 01:07:23

ya llena con 01:07:25

un RigidBody, con un componente 01:07:27

aquí no podemos aplicar fuerzas, es decir 01:07:29

aquí tenemos que decir 01:07:31

a este RigidBody que estoy guardando aquí 01:07:33

llamado AplicaFuerzas, le voy a añadir una fuerza 01:07:35

en este caso que sea 01:07:37

hacia arriba 01:07:39

para que sea hacia arriba 01:07:41

se podría hacer un vector 3 01:07:43

con los números 01:07:45

que nosotros queramos en cada eje 01:07:47

o se puede 01:07:49

usar una de las opciones simplificadas 01:07:51

que hay, por ejemplo el de Up 01:07:53

que es el de 01:07:55

que tiene una dirección hacia arriba 01:07:57

ahí estamos viendo que es el atajo 01:07:59

del 0, 1, 0 y el 1 es 01:08:01

el eje Y, el eje vertical 01:08:03

entonces aquí va a haber un salto 01:08:05

cuando choque va a añadir 01:08:07

una fuerza hacia arriba 01:08:09

ahora mismo va a ser muy pequeño 01:08:11

ese salto, va a aplicar muy poca fuerza 01:08:13

porque es solo un 1 01:08:15

más o menos se ve 01:08:17

voy a decir que esa fuerza 01:08:19

para que no sea un 0, 1, 0 01:08:21

lo voy a multiplicar por 100 01:08:23

esto para que se vea 01:08:25

claramente 01:08:27

le doy y cuando choca 01:08:29

y primero tendré que guardar 01:08:31

el script 01:08:33

esta guardada 01:08:35

AddForce, CollisionEnter 01:08:37

AplicaFuerzas, AddForce 01:08:39

vector 01:08:41

lo voy a poner mucho más 01:08:43

y guardo 01:08:45

cuando la pelota 01:08:47

la bola que es la que tiene 01:08:49

este script de fuerza choque toque otro 01:08:51

collider, le va a aplicar 01:08:53

a esta pelota una fuerza 01:08:55

hacia arriba 01:08:57

¿Qué está ocurriendo? 01:08:59

el problema que está viendo 01:09:01

cuando la pelota gira 01:09:03

es que ahora 01:09:05

me he pasado 01:09:07

veis que ahora cada vez que 01:09:13

choca con el suelo está aplicando 01:09:15

una fuerza, ahora no es el material que está dando el bote 01:09:17

es 01:09:19

que la pelota al chocar 01:09:21

está recibiendo una fuerza hacia arriba 01:09:23

por ejemplo en vez de decir 01:09:25

que vaya hacia 01:09:27

arriba vamos a decir que la fuerza sea hacia adelante 01:09:29

y por esto precisamente 01:09:31

es por lo que es importante lo de gestionar bien la orientación 01:09:33

que he dicho antes Javi 01:09:35

del juego porque el hacia adelante 01:09:37

se refiere en este caso hacia el eje Z 01:09:39

entonces cuando la pelota 01:09:41

esto quiere decir cuando la pelota colisione con algo 01:09:43

va a recibir una fuerza 01:09:45

de 1000 en este caso porque 01:09:47

está multiplicándose por eso en el vector 01:09:49

hacia el fondo, hacia el Z 01:09:51

y vais a ver que yo sin tocar nada 01:09:53

cuando toco ya tiene una fuerza 01:09:55

que se aplica, yo no he tocado nada, ¿veis? 01:09:57

de hecho si le doy más fuerte 01:09:59

voy a ponerle dos ceros más 01:10:01

va a ser demasiado, lo que va a hacer es salir disparado 01:10:03

precisamente en la dirección de la caja 01:10:05

y va a chocar contra la caja, de hecho me pasa 01:10:07

y le ha dado una fuerza 01:10:09

increíble, voy a quitarle un cero 01:10:11

¿vale? 01:10:13

aquí lanzó el juego y ahora sin tocar 01:10:15

nada, plas, le ha lanzado una fuerza 01:10:17

bastante fuerte, ¿vale? veis que la acción 01:10:19

de 01:10:21

añadir esta fuerza 01:10:23

se aplica en el momento que se detecta una colisión 01:10:25

¿vale? 01:10:27

entonces si 01:10:29

por ejemplo yo pusiera aquí un stay sería una locura 01:10:31

porque cada fotograma estaría aplicando 01:10:33

una fuerza de 10000 en este caso 01:10:35

entonces se irían sumando 01:10:37

o que cuando salga sea cuando aplique la fuerza 01:10:39

bueno, pues 01:10:41

esto me sirve 01:10:43

no sé si me vais siguiendo 01:10:45

sirve para 01:10:47

ir viendo que long collision enter 01:10:49

sirve para detectar 01:10:51

estas colisiones 01:10:53

por lo que he puesto este cubo 01:10:55

también tiene su rigid body 01:10:57

y a lo mejor lo que podemos hacer 01:10:59

esto es más avanzado, pero ya lo hemos hecho 01:11:01

realmente al instanciar, es 01:11:03

que podemos decir, ¿vale? 01:11:05

por código, vamos a hacer el planteamiento de que cuando 01:11:07

la bola colisione con algo 01:11:09

es decir, contra la plataforma va a ser lo primero que colisione 01:11:11

que sea el cubo el que reciba 01:11:13

una fuerza, claro ahí 01:11:15

ahora mismo el código 01:11:17

lo que está haciendo es 01:11:19

aplicar fuerza al componente 01:11:21

que lleva el objeto, porque estamos cogiendo el 01:11:23

componente, ¿vale? 01:11:25

al instanciado a la bola 01:11:27

porque está cogiendo el componente del 01:11:29

mismo objeto que tiene la bola, pero nosotros 01:11:31

por ejemplo aquí lo que podemos decir es 01:11:33

yo quiero que coja 01:11:35

el componente de otro objeto 01:11:39

si recordáis lo que hacíamos era 01:11:41

por ejemplo mediante un serialize field 01:11:43

lo que podemos hacer es 01:11:45

indicar objetos de la escena, ¿vale? 01:11:47

voy a decir que tal game object 01:11:49

que va a ser el cubo, ¿vale? 01:11:51

que sea el que del que 01:11:53

cojamos el componente, entonces 01:11:55

ahora mismo nosotros en esta bola 01:11:57

bueno, voy a guardar porque si no 01:11:59

no se refleja 01:12:01

lo que hemos hecho es que en el cubo 01:12:03

digo, en la bola, perdonad 01:12:05

haya un espacio esperando a que le digamos 01:12:07

oye, este objeto cubo 01:12:09

¿vale? que sea el que yo 01:12:11

referencio en 01:12:13

en este, en esta caja 01:12:15

que he creado aquí de un game object 01:12:17

entonces nosotros lo que podemos decir es 01:12:19

oye, yo quiero coger el componente 01:12:21

¿vale? pero de 01:12:23

el componente RigidBody pero de otro 01:12:25

objeto que está en la escena que es el cubo 01:12:27

¿vale? ahora mismo 01:12:29

lo que estamos haciendo es 01:12:31

¿vale? tenemos una caja de tipo RigidBody 01:12:33

en la que a través de esta variable 01:12:35

podremos introducirnos 01:12:37

en todos los parámetros 01:12:39

que tenga un componente RigidBody 01:12:41

pero, ¿vale? yo puedo decirle luego 01:12:43

¿vale? pero que este RigidBody lo que coja es 01:12:45

el componente 01:12:47

RigidBody, ¿vale? es el mismo 01:12:49

componente, se escribe así la sintaxis 01:12:51

hay que aprendérsela, del objeto 01:12:53

que yo haya indicado que es este cubo 01:12:55

¿vale? ahora mismo estamos 01:12:57

a través de un script que está 01:12:59

en la bola, luego afectando 01:13:01

a otro objeto que hemos 01:13:03

indicado mediante el serializeField 01:13:05

entonces ahora aplicar fuerzas en todo momento 01:13:07

a quien está afectando, no es a la bola 01:13:09

está cogiendo el componente RigidBody 01:13:11

del cubo, ¿vale? porque aquí 01:13:13

estamos afectando al cubo 01:13:15

entonces vais a ver ahora que 01:13:17

cuando la pelota 01:13:19

toque, voy a de hecho 01:13:21

hacer que el cubo este ya posado 01:13:23

¿vale? para que veáis que no es, porque 01:13:25

el cubo está tocando, sino que es la pelota 01:13:27

cuando yo 01:13:29

consiga que la pelota colisione con algo 01:13:31

veis que el cubo se ha ido bien lejos 01:13:33

voy a bajarle un poco la fuerza para que se vea mejor 01:13:35

¿vale? entonces 01:13:37

aquí estamos referenciando un objeto con otro 01:13:39

¿vale? cuando tal 01:13:41

se ha ido para adelante, ha salido despedido 01:13:43

¿vale? ¿qué tal hasta aquí? 01:13:45

me vais siguiendo, esto me sirve un poco para que veáis 01:13:47

el GetComponent, ¿vale? o por 01:13:49

ejemplo, también hay formas más avanzadas 01:13:51

ya las iremos poniendo en juego 01:13:53

que es que en vez de decir 01:13:55

mediante un serializeField 01:13:57

y arrastrando al inspector, como hacíamos 01:13:59

en las instancias, que sea el otro objeto 01:14:01

en el que se introduzca para coger el componente 01:14:03

hay otras formas de 01:14:05

hacer esto, que es por ejemplo 01:14:07

el método 01:14:09

find, que es si aquí decimos 01:14:11

que un GameObject 01:14:13

busque 01:14:15

un objeto que tenga 01:14:17

un nombre concreto 01:14:19

¿vale? por ejemplo, esto es simplemente para que os suene 01:14:21

que existe ¿vale? entiendo que ahora mismo es más avanzado 01:14:23

pero si vamos a 01:14:25

viendo que dentro de la clase GameObject 01:14:27

hay un, igual que aquí pasaba 01:14:29

que hasta que no estamos usando una 01:14:31

variable de tipo RigidBody, no sale 01:14:33

statForce, cuando ponemos la clase 01:14:35

GameObject ¿vale? la clase con la 01:14:37

G mayúscula, hay un método 01:14:39

suyo que es find, y find sirve 01:14:41

como pasa si nos ponemos aquí 01:14:43

que encuentra objetos 01:14:45

GameObject por un nombre ¿vale? 01:14:47

y entonces ahora estamos diciendo, oye 01:14:49

en el nivel que estemos, búscame 01:14:51

a ver si hay un GameObject 01:14:53

llamado cubo ¿vale? que es el que hemos dicho 01:14:55

y si existe ¿vale? 01:14:57

cuando lo busques, coge de ese objeto 01:14:59

su componente RigidBody 01:15:01

el que esté dentro de cubo ¿vale? 01:15:03

ahora mismo lo que estamos haciendo es lo mismo 01:15:05

¿vale? sin tener 01:15:07

sin tener que apelar a 01:15:09

ningún objeto mediante el 01:15:11

inspector, es decir, ahora la bola 01:15:13

no tiene ningún campo 01:15:15

en ningún momento hemos dicho que sea el cubo 01:15:17

arrastrando del que coja este componente 01:15:19

hemos dicho, oye busca 01:15:21

que haya un objeto que se llame cubo, y si eso 01:15:23

guarda en esta variable aplicarFuerza 01:15:25

su RigidBody, y ahora 01:15:27

aplicarFuerza le estamos diciendo 01:15:29

que a este RigidBody que hemos guardado 01:15:31

le aplicamos esa fuerza, y vais a ver que el comportamiento 01:15:33

es en lo mismo ¿vale? 01:15:35

a ver, he bajado 01:15:37

ah vale, le he bajado un poco la fuerza 01:15:39

pero veis que cuando 01:15:41

a ver, cuando yo, cuando la bola 01:15:43

conseguimos que toque esa superficie, le aplica 01:15:45

una fuerza al cubo, es decir 01:15:47

un script que se encuentra en la bola 01:15:49

está afectando 01:15:51

a un componente de otro objeto 01:15:53

hasta aquí 01:15:55

¿qué tal? esto me sirve un poco para hablar 01:15:57

del GetComponent dado que hay que usarlo 01:15:59

en esta práctica para ir 01:16:01

para afectar a los RigidBodies 01:16:03

¿si? 01:16:05

¿qué tal? decidme algo, porfa 01:16:07

un poco complicado 01:16:11

vale, lo que hay que, esto si lo vais 01:16:13

practicando, vale, lo iréis viendo 01:16:15

de momento, lo que me importa es 01:16:17

que podéis crear, vale, un poco el resumen 01:16:19

es que podéis crear variables 01:16:21

cuando queráis cambiar algo de un componente 01:16:23

vale, tendréis que crear una variable 01:16:25

de ámbito global, vale, que esté en todo el script 01:16:27

aquí fuera, del start y del resto de métodos 01:16:29

del nombre 01:16:31

de esa 01:16:33

de ese componente, vale 01:16:35

le ponéis un nombre de variable y luego 01:16:37

con esto no vale solo, luego 01:16:39

a esa variable también habrá que capturar 01:16:41

su componente, vale 01:16:43

por ejemplo, a lo mejor en 01:16:45

la propia bola 01:16:47

una pregunta antes de que sigas 01:16:49

cuando dices capturar su componente, ¿te refieres a poner 01:16:51

el nombre del componente del objeto al que 01:16:53

le quieres aplicar, no? en ese caso era 01:16:55

el cubo, el otro o cualquier otro, ¿no? 01:16:57

si, aquí está todo lo del 01:16:59

cubo, vale, eso me servía para deciros que este 01:17:01

getComponent 01:17:03

lo que hacemos es meter 01:17:05

en las posibilidades que tiene 01:17:07

este RigidBody, esta clase, vale 01:17:09

le tenemos que decir que 01:17:11

al componente que se refiere, que coja el 01:17:13

que está en el mismo objeto 01:17:15

como no se especifica objeto, vale 01:17:17

es lo mismo que poner esto 01:17:19

cuando nosotros ponemos getObject 01:17:21

vale, estamos refiriéndonos al 01:17:23

propio getObject que tiene este script, ¿no? 01:17:25

entonces estamos diciendo que 01:17:27

de este getObject que tiene el script 01:17:29

que coja su componente RigidBody y me lo guardas 01:17:31

en la variable que he creado para ese 01:17:33

componente, vais a verlo, esto lo vais 01:17:35

a usar también en el animator, en otros 01:17:37

componentes que hay, es muy 01:17:39

repetitivo, hay que crear una variable con el nombre 01:17:41

del componente, por ejemplo 01:17:43

imaginaos que es lo que iba a decir 01:17:45

que quiero afectar a algo del 01:17:47

sphereCollider, vale, entonces yo puedo 01:17:49

ahora crear una clase 01:17:51

una variable llamada 01:17:53

sphereCollider, veis que existe 01:17:55

y la llamo sc 01:17:57

porque es el nombre que yo he querido, vale 01:17:59

y luego para afectar 01:18:01

para cambiar cualquiera de las 01:18:03

funcionalidades que tengo en el sphereCollider 01:18:05

habrá que hacer algo parecido, le voy a decir 01:18:07

esa variable que he creado, pues 01:18:09

cógeme el componente de este objeto 01:18:11

que se llama, vale 01:18:13

y esta sintaxis hay que aprendérsela, es así 01:18:15

uy va, espera, he escrito algo muy raro 01:18:17

entre 01:18:19

estos símbolos de más menos ponemos 01:18:21

otra vez, vale, y es repetitivo porque 01:18:23

funcionalmente queremos guardar en esa 01:18:25

variable el mismo componente 01:18:27

vale, coge el componente llamado 01:18:29

sphereCollider que hay dentro de ese GameOverKit 01:18:31

vale, y ahora 01:18:33

todo lo que yo haga sobre sc 01:18:35

si le doy al punto, va a tener 01:18:37

las propiedades de 01:18:39

de ese 01:18:41

sphereCollider, por ejemplo 01:18:43

si yo 01:18:45

le doy a isTrigger, vale 01:18:47

isTrigger 01:18:49

lo que voy a poder hacer es 01:18:51

que el isTrigger sea falso o 01:18:53

verdadero 01:18:55

a ver, espera, porque esto ahora mismo tendría 01:18:57

que saber cómo se varía, a ver un segundo 01:18:59

que esto me lo va a decir aquí 01:19:01

isTrigger, vale 01:19:03

pero fijaos que me están saliendo ahora opciones 01:19:05

que se encuentran dentro de este 01:19:07

componente 01:19:09

por ejemplo, si quisiera cambiar 01:19:11

el centro o el radio de esta 01:19:13

sphereCollider, vamos a ver que hay 01:19:15

una opción que se llama 01:19:17

Radius, vale, y yo ahora 01:19:19

en Radius, importante para 01:19:21

saber cómo se trabaja con cada uno 01:19:23

mirad que es lo que os pide, vale 01:19:25

el radio de la sphere a medida 01:19:27

en el objeto local space 01:19:29

vale, como el radio aquí 01:19:31

el Radius es un número, yo puedo decir 01:19:33

fijaos, vale, es un 0.5 y yo puedo 01:19:35

decirle, no, el Radius 01:19:37

lo voy a poner 01:19:39

en el update para que se los ejecute una vez 01:19:41

el Radius, lo que quiero es que cuando empiece 01:19:43

el juego, por código yo voy a poder 01:19:45

cambiar a que valga 2 01:19:47

vale, y vais a ver que yo 01:19:49

y guardo, aunque yo antes de lanzar 01:19:51

el juego, está aquí en el 01:19:53

vector como 0.5, cuando yo 01:19:55

lance el juego en el start, me lo voy a poner 01:19:57

como un 2, lo veis 01:19:59

y ahora de pronto, que 01:20:01

igual este es el problema que te pasaba 01:20:03

Javi, que ahora está flotando 01:20:05

se ha ampliado el radio 01:20:07

del Collider y por eso está flotando 01:20:09

que es lo que te he dicho antes, digo, parece que está flotando 01:20:11

pues, será que es que el Collider lo tiene más grande 01:20:13

vale, entonces 01:20:15

lo que me sirve es para ver 01:20:17

cómo podemos 01:20:19

entrar en cada componente haciendo este esquema 01:20:21

de declarar el componente con su tipo 01:20:23

luego, lo capturamos 01:20:25

de este modo, poniendo aquí el nombre de ese 01:20:27

componente y luego ya 01:20:29

pues tenemos estas variables, aplicarFuerzas 01:20:31

y sc, que si ponemos un punto 01:20:33

vale, nos permiten 01:20:35

acceder a los métodos asociados 01:20:37

con ese 01:20:39

con ese componente 01:20:41

por ejemplo el isTrigger 01:20:43

que es un check 01:20:45

vale, especifica si este Collider está configurado 01:20:47

como un trigger, tendría que ver la documentación 01:20:49

porque ahora mismo no me acuerdo, pero en teoría 01:20:51

si lo ponemos, vale 01:20:53

como es un booleano, vale 01:20:55

es o sí o no, vale 01:20:57

fijaos que el isTrigger incluso 01:20:59

cuando choque 01:21:01

podríamos incluso ponerlo aquí en el collisionEnter 01:21:03

podríamos decir, cuando 01:21:05

el 01:21:07

cuando el 01:21:09

la bola 01:21:11

colisione con algo, quiero que 01:21:13

el radio de la esfera 01:21:15

cambie a 2 y el isTrigger pasa a ser 01:21:17

falso, vale, entonces 01:21:19

o verdadero, mejor dicho, para que sea 01:21:21

para que de pronto vais a ver 01:21:23

que esta casilla cuando choca 01:21:25

se pone verdadera y lo va a atravesar, no 01:21:27

es decir, yo ahora le doy al play y cuando toque 01:21:29

la pelota con algo 01:21:31

con colisione, que en el primer momento va a ser esta 01:21:33

esta madera, va a 01:21:35

cambiar del 01:21:37

componente FirCollider el radio a 2 01:21:39

y el isTrigger 01:21:41

se va a marcar y cuando lo 01:21:43

se convierta en isTrigger lo va a atravesar, porque de pronto 01:21:45

se ha convertido en un trigger 01:21:47

ya no va a estar funcionando como Collider 01:21:49

de pronto va a pasar a ser un trigger, vale 01:21:51

vais a ver que cuando choca 01:21:53

de pronto se marca y se pone en 2 01:21:55

y aparte me han atravesado porque en algún 01:21:57

momento habíamos puesto, ah vale 01:21:59

que el precipicio estaba 01:22:01

con el me ha atravesado este de que 01:22:03

de que 01:22:05

que teníamos aquí puesto, vale, se están sumando 01:22:07

ya las cosas, no, que es que cuando la bola 01:22:09

o algo colisionara con este 01:22:11

precipicio pues lo atravesaba 01:22:13

y en todo momento en el 01:22:15

que estuviera, vuelvo a abrir este 01:22:17

esto que teníamos aquí 01:22:19

cuando, a ver 01:22:21

este no es 01:22:23

teníamos el 01:22:25

perdonad, el precipicio 01:22:27

no, como lo llamo yo 01:22:29

ah, el reinicio, espera 01:22:31

reinicio nivel, aquí está, vale, en el 01:22:33

onTriggerState que pusiera me han atravesado y por eso 01:22:35

lo ha hecho, vale, y todo se está desencadenando 01:22:37

ya por triggers y por colliders 01:22:39

y por, es decir 01:22:41

el onCollision, vale, más o menos 01:22:43

hasta aquí me vais siguiendo y es 01:22:45

importante, bueno, va a ser esencial esto 01:22:47

que estoy hablando de coger los componentes 01:22:49

y poder operar con los componentes 01:22:51

a través de 01:22:53

de código 01:22:55

vale, es decir, ahora mismo ya hemos 01:22:57

aprendido en esto que estamos viendo 01:22:59

lo repito, lo iréis practicando 01:23:01

vale, pero con esto de component 01:23:03

y las clases, las variables que tienen 01:23:05

un tipo de variable 01:23:07

que es una clase realmente relacionada 01:23:09

con un componente, podemos acceder 01:23:11

a cualquier de los parámetros y cambiar por código 01:23:13

cualquiera de los parámetros 01:23:15

o casi cualquiera de los scripts 01:23:17

de los, perdonad, de los componentes 01:23:19

que vayamos aquí 01:23:21

todos los que hay, que vayamos haciendo 01:23:23

que tenemos más adelante en el tema 4 01:23:25

que tenemos un texto que queremos que ponga algo 01:23:27

pues accederemos a su componente 01:23:29

del texto 01:23:31

y lo podremos cambiar por código 01:23:33

y la operación será siempre similar 01:23:35

vale, declarando el tipo de variable 01:23:37

pues por ejemplo Renderer 01:23:39

vale, el mesRenderer tiene 01:23:41

una clase que es Renderer 01:23:43

pues con esto 01:23:45

pues yo que sé, en Renderer 01:23:47

nos meteríamos en el Renderer 01:23:49

¿que queremos afectar algo al Renderer? 01:23:51

primero tendremos que coger 01:23:53

su componente 01:23:55

que es Renderer, aunque se llame mesRenderer 01:23:57

este si que tiene la particularidad 01:23:59

que solo hay que poner Renderer 01:24:01

pues ahora por ejemplo 01:24:03

podríamos desde aquí, desde el código 01:24:05

perdonad 01:24:07

desde el código podríamos 01:24:09

por ejemplo cambiar su color 01:24:11

ya es más avanzado porque además este 01:24:13

como tiene tantas propiedades 01:24:15

tiene más 01:24:17

características 01:24:19

pero yo que sé 01:24:21

en el Start también 01:24:23

una vez tenemos aquí ya el Renderer 01:24:25

podemos decir, si no me equivoco 01:24:27

no me acuerdo, había que hacer 01:24:29

material, color 01:24:31

vale, y por ejemplo desde aquí 01:24:33

todo partiendo de que hemos capturado 01:24:35

el Renderer podemos decirle 01:24:37

que el color sea, yo que sé 01:24:39

black 01:24:41

color black, vale 01:24:43

esto ya os digo que es más avanzado 01:24:45

pero vais a ver que ahora al empezar el juego 01:24:47

la pelota se debería volver negra 01:24:49

bueno, aparte de todo lo que ya habíamos hecho 01:24:51

entonces desde el código podemos ir 01:24:53

cambiando todas las opciones que están 01:24:55

configuradas en los componentes 01:24:57

vale, esto lo estoy contando así un poco con ejemplos 01:24:59

de ya más componentes pero 01:25:01

me sirve para que sepáis 01:25:03

que este es el primer paso que estamos dando 01:25:05

para afectar, o al menos 01:25:07

consciente, para afectar a los componentes 01:25:09

y claro, con los componentes es donde vamos 01:25:11

cambiando todas las opciones 01:25:13

el Transform, vale, que hasta ahora hemos 01:25:15

usado en las primeras prácticas para cambiar el 01:25:17

position, la rotación, etc 01:25:19

no había que hacer todo este proceso 01:25:21

porque como es el componente 01:25:23

por defecto que viene con los 01:25:25

GameObjects, vale 01:25:27

ya viene configurado para que al hacer 01:25:29

al poner la palabra Transform, vale 01:25:31

no haya que hacer esto de capturar 01:25:33

porque es que siempre está, entonces la palabra 01:25:35

Transform con minúscula aquí 01:25:37

ya está apelando al 01:25:39

y si veis aquí abajo a la clase Transform 01:25:41

con mayúscula, vale, lo mismo que estamos 01:25:43

haciendo aquí, aquí también podríamos poner 01:25:45

Transform, vale, y estamos hablando 01:25:47

de esa variable, pero esta ya 01:25:49

del propio objeto que tiene 01:25:51

bueno, pues el propio GameObject 01:25:53

cuando ponemos el Transform ya, pues por ejemplo 01:25:55

podemos llamar a 01:25:57

la posición, y no deja de ser 01:25:59

uno de los valores, uno de los campos 01:26:01

que están aquí preparados en un 01:26:03

componente, vale, solo que para el 01:26:05

resto de componentes, pues hay que hacer 01:26:07

esta operación, y como hemos visto además 01:26:09

mmm, también está 01:26:11

simplificada porque esto, y esto es exactamente 01:26:13

lo mismo, vale, es una subclase 01:26:15

un método que está dentro de 01:26:17

un componente superior 01:26:19

me vais siguiendo hasta aquí 01:26:21

más o menos, me estoy deteniendo mucho 01:26:23

en esto, pero es que es básico para de aquí 01:26:25

en adelante 01:26:27

vale, esto cuando 01:26:29

vayáis haciendo la práctica, como al RigidBody 01:26:31

tenéis que aplicarle fuerzas o torques 01:26:33

no, vais a tener que 01:26:35

acceder 01:26:37

a un RigidBody siempre, así que en esta práctica 01:26:39

ya por narices, tenéis 01:26:41

que ponerlo en juego, sí, a ver 01:26:43

eh, alguien, ah, vale, no, que pensaba 01:26:45

que habéis dicho algo, que hacen algo por ahí, vale 01:26:47

entonces 01:26:49

eh, fuerza choque 01:26:51

lo voy a guardar y lo voy a 01:26:53

quitar de este objeto porque lo he hecho de prueba 01:26:55

pero yo no quiero que la bola le dé 01:26:57

ninguna fuerza a otro elemento 01:26:59

o a sí misma cuando choque, yo quiero que por la gravedad 01:27:01

pues se quede ahí, vale 01:27:03

entonces, aquí está la bola 01:27:05

el cubo este lo voy a ocultar 01:27:07

vale, lo voy a dejar ahí pero 01:27:09

inactivo, mejor dicho 01:27:11

y ahora, aquí está 01:27:13

vale 01:27:15

hasta aquí tenemos esto 01:27:17

la bola, vale 01:27:19

y para ir un poco más ágil 01:27:21

voy a abrir directamente 01:27:23

el script que yo he aplicado a la bola en este caso 01:27:25

vale, para no hacerlo de cero, pero si 01:27:27

os fijáis, lo que se ha hecho 01:27:29

ahora además que ya hemos hablado de varias cosas 01:27:31

es 01:27:33

declarar varias variables 01:27:35

vale, que sean globales 01:27:37

recordad que las que 01:27:39

se declaran aquí encima 01:27:41

fuera de todo el resto de métodos 01:27:43

vale, serán variables que luego 01:27:45

se podrán ir usando sin problema 01:27:47

dentro del resto de métodos 01:27:49

que no es lo mismo que declararla dentro de un método 01:27:51

que recordad que se encapsulaba 01:27:53

y se quedaba en local 01:27:55

y por tanto, pues 01:27:57

habría métodos que no se pueden usar 01:27:59

en otra sección 01:28:01

en otro módulo, vale 01:28:03

en otra función de ejecución 01:28:05

esto ya lo vimos en su momento 01:28:07

si tenéis duda me vais diciendo 01:28:09

entonces aquí, básicamente 01:28:11

cuando se estaba planteando qué hacer con la bola en este nivel 01:28:13

pues era, yo lo que voy a querer es 01:28:15

mover la bola horizontal y verticalmente 01:28:17

o al menos 01:28:19

aunque sea en profundidad, vale 01:28:21

que la captura del movimiento sea 01:28:23

con la lógica vertical, es decir, la flecha hacia arriba 01:28:25

y la flecha hacia abajo, vale 01:28:27

y son valores que están 01:28:29

asociados a un float, vale 01:28:31

luego va a haber otras dos variables 01:28:33

que sirven para dar luego, para multiplicar 01:28:35

por una fuerza 01:28:37

o por una fuerza pero de torsión, vale 01:28:39

que también son floats, voy un poco rápido 01:28:41

porque creo que esto 01:28:43

se explica solo y si no, volvemos a ello 01:28:45

aquí se ha declarado una wake, que es otro momento 01:28:47

de ejecución que vimos el otro día 01:28:49

no nos hace falta, lo borro, vale 01:28:51

y luego este RigidBody 01:28:53

porque hasta que no hacemos la operación 01:28:55

de aplicar fuerzas 01:28:57

a un RigidBody concreto, vale 01:28:59

que si veis es exactamente la misma operación 01:29:01

que había hecho, he declarado 01:29:03

la variable RigidBody y luego al empezar 01:29:05

este script, al ejecutarse 01:29:07

pues oye, en esta variable 01:29:09

RigidBody captúrame o guarda 01:29:11

o apela o no sé 01:29:13

get, coge el componente 01:29:15

RigidBody que como no hemos puesto 01:29:17

nada más, que sea el que tiene 01:29:19

el propio objeto, es decir, ahora mismo 01:29:21

con este código, estamos ya teniendo 01:29:23

una puerta al RigidBody que tiene la bola 01:29:25

que es el mismo 01:29:27

GameObject que tiene aplicado este componente 01:29:29

vale, luego 01:29:31

más adelante al empezar, ya 01:29:33

como luego lo vamos a usar para multiplicar aquí 01:29:35

vale, como hacíamos con el speed 01:29:37

en la variable speed 01:29:39

de por ejemplo la práctica 2, no 01:29:41

o velocidad, aquí hemos puesto 01:29:43

que al empezar el juego, pues se guarden 01:29:45

estas variables de float, pues un 60 01:29:47

y un 80, esto pues se puede cambiar 01:29:49

para que tenga más o menos fuerza 01:29:51

en el update 01:29:53

importante, vale 01:29:55

hemos llamado 01:29:57

a estas dos variables que habíamos declarado 01:29:59

aquí, que por cierto 01:30:01

son serializeField, sólo para poder 01:30:03

verlas en vivo 01:30:05

y directo, cuando ejecutemos el juego 01:30:07

vale, para que se vean aquí 01:30:09

vale, que cuando yo esté 01:30:11

pulsando una tecla, vale 01:30:13

ahora lo vemos, veis que van del 0 01:30:15

del 1 al menos 1, según estoy 01:30:17

pulsando teclas con los valores 01:30:19

intermedios, pero realmente 01:30:21

lo he hecho serializable para 01:30:23

poder visualizar 01:30:25

aquí los valores 01:30:27

vale, pero no estoy, bueno 01:30:29

veis que si arrastro en vivo hacia la izquierda 01:30:31

o hacia la derecha, estoy dando 01:30:33

valores a estas 01:30:35

variables, vale, aunque 01:30:37

no se vea el número porque es una ejecución 01:30:39

muy rápida, veis que la bola 01:30:41

si yo voy hacia la derecha con el ratón o hacia la 01:30:43

izquierda, se va moviendo 01:30:45

entonces 01:30:47

tengo aquí dos variables 01:30:49

de mover, horizontal 01:30:51

o vertical, que lo que están capturando 01:30:53

es un axis 01:30:55

vale, llamado vertical bola 01:30:57

o horizontal bola, y la está guardando 01:30:59

el concepto de getAxis 01:31:01

¿qué tal lo tenéis? 01:31:03

ya, esto es del tema 2 01:31:05

pero, ¿sabéis que 01:31:07

porque estoy usando un getAxis y no estoy 01:31:09

poniendo el 01:31:11

si le doy a la tecla 01:31:13

que sea el vector hacia arriba, si le doy 01:31:15

¿sabéis porque estoy usando el axis? es decir 01:31:17

es algo que si no me voy a parar 01:31:19

el getAxis es porque utilizas las teclas 01:31:21

de movimiento de las flechas y ya 01:31:23

automáticamente se pone, me parece, ¿no? 01:31:25

eso es, es decir 01:31:27

el axis, vale, tengo que ir 01:31:29

un segundo al, recordad que los 01:31:31

ejes se configuran en los project 01:31:33

settings, vale, en el input manager, están 01:31:35

estos axis, vale, que tenían sus 01:31:37

nombres, vale, aquí yo he 01:31:39

creado más, pero vais a fijaros que hay 01:31:41

a ver, uno que se llama vertical bola 01:31:43

y horizontal bola, que son los que estoy usando 01:31:45

ahora, y dentro de esto 01:31:47

hemos configurado, vale 01:31:49

esto ya lo vimos el otro día un poco 01:31:51

si no lo decimos, que haya 01:31:53

un eje, vale, un axis, los axis 01:31:55

son como ejes, que el 01:31:57

negativo sea la A 01:31:59

y el positivo sea la D 01:32:01

¿esto que significa? que este eje 01:32:03

tiene un menos uno en la A 01:32:05

un uno en la D 01:32:07

vale, y yo cuando vaya tocando uno de 01:32:09

esos dos extremos, como voy a hacer ahora 01:32:11

a ver, espera, cuando yo 01:32:13

le de a la tecla, fijaos que 01:32:15

lo que está capturando hasta 01:32:17

tarda un tiempo en llegar, es o menos uno 01:32:19

y cuando doy a la derecha uno 01:32:21

a la izquierda menos uno, vale, es un eje 01:32:23

que tiene dos extremos, dos valores 01:32:25

y esto es muy útil, como pasa 01:32:27

en los joystick, son los mandos 01:32:29

que tenemos siempre dos ejes, el horizontal 01:32:31

y el vertical, ahora tengo el otro, vale 01:32:33

que le doy a arriba o abajo 01:32:35

a la W o a la S 01:32:37

y va de uno a menos uno 01:32:39

esta es la forma más óptima que ir poniendo 01:32:41

vale, lo digo, voy a ir un segundo a 01:32:43

uno de los hilos del foro 01:32:45

una compañera estaba trabajando 01:32:47

a ver, perdonad 01:32:49

esto yo lo tenía ya abierto, pero 01:32:51

vale, creo que ha sido aquí 01:32:53

justo, un segundo 01:32:55

una compañera estaba 01:32:57

incorporando todos los 01:32:59

inputs por teclas independientes 01:33:01

y hombre, por poder se puede 01:33:03

pero es mucho menos eficiente y no tiene 01:33:05

no tiene 01:33:07

la mejor lógica, entonces 01:33:09

si nos metemos, vale, si queréis 01:33:11

revisar, que también está la respuesta 01:33:13

esta compañera 01:33:15

lo que estaba haciendo era 01:33:17

que todos los inputs, si os fijáis era 01:33:19

flecha arriba 01:33:21

esta fuerza, si no 01:33:23

si esta flecha a la izquierda 01:33:25

si no esta flecha a la derecha 01:33:27

si no esta flecha abajo, vale 01:33:29

estaba haciendo por cada 01:33:31

tecla una dirección de fuerza 01:33:33

vale, y esto es una 01:33:35

es un enfoque que implica 01:33:37

muchas líneas y cuando estamos 01:33:39

usando elementos que lo que tienen son 01:33:41

dos ejes de dirección, es decir, izquierda a derecha 01:33:43

arriba a abajo, en profundidad 01:33:45

hacia adelante o hacia detrás 01:33:47

con un eje podemos ir 01:33:49

reflejando de manera muy sencilla 01:33:51

los dos extremos de una dirección, vale 01:33:53

en vez de usar dos controles diferentes 01:33:55

para arriba y abajo, con el eje 01:33:57

tenemos ese 01:33:59

ese recorrido entre un punto y el otro 01:34:01

y si no estamos haciendo ningún 01:34:03

input, será cero 01:34:05

esto del x axis, además a diferencia de esto 01:34:07

cuando tocamos una tecla es 01:34:09

o sí o no, es decir, si pulsas una tecla 01:34:11

no hay sensibilidades, se activa o no se 01:34:13

activa, con los axis 01:34:15

si estuviéramos usando un 01:34:17

joystick, entre ese menos uno 01:34:19

o el uno que marcan los 01:34:21

extremos del joystick, tenemos valores 01:34:23

intermedios para darle sensibilidad 01:34:25

vale, no tengo aquí el joystick pero igual que 01:34:27

cuando estamos ejecutando el juego 01:34:29

vemos aquí 01:34:31

que hay un momento que hasta 01:34:33

que llega al uno, vale, fijaos aquí 01:34:35

pues hay unos valores intermedios 01:34:37

que si estamos con el axis configurado 01:34:39

para un joystick, si yo pulso 01:34:41

la mitad del joystick hacia abajo 01:34:43

vale, pues se quedaría en el menos cero con cinco 01:34:45

vale, y sería el valor que está 01:34:47

guardando esta variable moveH que es la que 01:34:49

tenemos aquí preparada, vale 01:34:51

moveH está cogiendo el input 01:34:53

de horizontal bola 01:34:55

y no deja de ser un float, es un número 01:34:57

que al estar configurado como un getAxis 01:34:59

va entre el menos uno y el uno 01:35:01

que vamos a hacer con eso, que en todo momento 01:35:03

al multiplicar un vector 01:35:05

por menos uno o por uno, estamos 01:35:07

dándole ya una dirección 01:35:09

vale, pero que puede ser 01:35:11

hacia un lado o hacia el otro 01:35:13

al ser negativo este vector forward por defecto 01:35:15

si me pongo encima es uno hacia adelante 01:35:17

si lo multiplico por uno 01:35:19

pues será hacia adelante, pero si lo 01:35:21

multiplico por menos uno 01:35:23

irá hacia atrás, vale 01:35:25

entonces con un solo 01:35:27

con una sola variable bien configurada 01:35:29

ya tenemos las dos direcciones de manera muy fácil 01:35:31

ahora mismo en esta línea estamos 01:35:33

añadiendo una fuerza en profundidad, vale 01:35:35

con el vector de profundidad que se mueve 01:35:37

según el input que estemos dando 01:35:39

si no le damos ningún input 01:35:41

como esto va a valer cero, pues esto 01:35:43

vale cero y no se mueve, no se aplica ninguna fuerza 01:35:45

vale, y luego aparte tenemos 01:35:47

esta variable de fuerza que es otro float 01:35:49

que nos sirve para, oye esto que estamos 01:35:51

aquí ejecutando, pues que se multiplique 01:35:53

por esta fuerza, entonces 01:35:55

si se mueve muy despacín, pues la fuerza 01:35:57

la aumentamos, vale, o la disminuimos 01:35:59

fijaos que tengo 01:36:01

un forward para avanzar 01:36:03

porque lo he hecho, lo he 01:36:05

disgregado en dos tipos de fuerza 01:36:07

distintas, para ir hacia adelante y hacia atrás 01:36:09

se ha 01:36:11

puesto aquí esta 01:36:13

fuerza 01:36:15

invertido 01:36:17

aquí lo que no sé es porque, bueno 01:36:19

si se está duplicando una 01:36:21

esto podría estar comentado borrado, de hecho 01:36:23

esto es un error, pues se está aplicando el torque 01:36:25

dos veces, vale, y aquí 01:36:27

lo que estamos haciendo es lo mismo para añadir 01:36:29

un torque en relación 01:36:31

al horizontal, vale 01:36:33

es decir, hacia adelante y hacia atrás, ahora mismo 01:36:35

se está aplicando la fuerza con el 01:36:37

move V, que es lo que tengo 01:36:39

configurado ahora mismo con la W y la S 01:36:41

y los laterales son 01:36:43

la A y la D, que lo mismo, están 01:36:45

aplicando una fuerza según el input 01:36:47

que estamos recibiendo, vale 01:36:49

aquí se vería 01:36:51

que es un número float que multiplica el resto 01:36:53

de elementos, y ojo 01:36:55

y ahora, alguien creo que va a preguntar algo 01:36:57

aquí vais a decir, que raro 01:36:59

no, que para ir hacia adelante 01:37:01

y hacia atrás sea forward, pero para 01:37:03

girar hacia los lados también sea forward 01:37:05

vale, pero es que recordad 01:37:07

también lo ponen los apuntes, que el torque 01:37:09

se hace en relación a un eje 01:37:11

es decir, nosotros realmente lo que queremos 01:37:13

es que gire con respecto 01:37:15

al eje forward, al de 01:37:17

profundidad, vale, en torno a ese eje 01:37:19

ya hará el giro, vale 01:37:21

no es hacia donde se mueve, como en la fuerza 01:37:23

sino, en torno a que eje empieza a girar 01:37:25

vale 01:37:27

si, a ver, alguien 01:37:29

me quería preguntar algo, creo 01:37:31

si, mira, una cosa, en vez de poner 01:37:33

menos vector 3 forward 01:37:35

vector third back, por ejemplo 01:37:37

efectivamente, vale, esto 01:37:39

si que hay métodos 01:37:41

vale, que no permiten usar todos los 01:37:43

atajos de vector 3 y a veces solo se puede 01:37:45

usar el forward, porque por lo que sea 01:37:47

está limitado, en este caso 01:37:49

que no existe el problema 01:37:51

es lo mismo invertir 01:37:53

el forward que poner vector back, vale 01:37:55

ahora mismo le voy a dar al juego y va a ser 01:37:57

exactamente igual que lo otro que tenía 01:37:59

vale, se mueve y cuando doy 01:38:01

a la tecla va a la izquierda y la doy 01:38:03

a la derecha, vale 01:38:05

vale, y luego 01:38:07

otra pregunta, cuando haces torque 01:38:09

entiendo que es 01:38:11

lo que haces es mover 01:38:13

no te estoy escuchando, acércate más al micrófono 01:38:15

si, ahora si 01:38:17

ahora si 01:38:19

lo que haces es mover 01:38:21

lo que sea, la pelota o la plataforma 01:38:23

o el palo, lo que sea 01:38:25

sobre su propio eje, no sobre el eje del mundo 01:38:27

entiendo 01:38:29

lo hace sobre sí mismo, si 01:38:31

sobre sí mismo, eso me refiero 01:38:33

lo hace en relación 01:38:35

a las coordenadas del mundo 01:38:37

porque, si no se vería 01:38:39

a ver si, espera 01:38:41

déjame que lo piense un segundo 01:38:43

si yo 01:38:45

no lo hiciera sobre el mundo 01:38:47

vale, piensa una cosa 01:38:49

la pelota y fíjate 01:38:51

fíjate por ejemplo en las líneas 01:38:53

que está marcando el collider 01:38:55

vale, yo cuando voy rotando 01:38:57

ves que va cambiando la orientación, también fíjate aquí 01:38:59

como cambia hacia donde es 01:39:01

el arriba abajo 01:39:03

de la propia bola, vale 01:39:05

ese es el relativo a la bola, la posición 01:39:07

está cambiando en todo momento 01:39:09

y sin embargo yo cuando le doy a la W 01:39:11

va hacia delante 01:39:13

da igual en que momento esté girado 01:39:15

si estos movimientos y estos torques 01:39:17

no se hicieran en relación al propio objeto 01:39:19

cuando yo, que de hecho 01:39:21

se puede hacer, ahora vamos a hacer un ejemplo 01:39:23

si esto no fuera con respecto 01:39:25

al mundo, vale, pues la pelota 01:39:27

iría hacia delante en relación 01:39:29

a donde ya estuviera girada la pelota, es decir 01:39:31

que si yo aquí la he girado un poquito 01:39:33

y está mirando el 01:39:35

frente hacia abajo, cuando yo le diera 01:39:37

hacia abajo, intentaría ir hacia abajo, pero no lo está 01:39:39

intentando 01:39:41

entonces es hacia el mundo 01:39:43

es verdad que luego existe 01:39:45

aquí más o menos va a funcionar, porque como es un objeto redondo 01:39:47

va a aplicar fuerza, pero 01:39:49

cuando quieras que estos 01:39:51

estas fuerzas se apliquen 01:39:53

con respecto al 01:39:55

la orientación del propio 01:39:57

objeto, la local, vale 01:39:59

hay otros métodos 01:40:01

como el transform forward 01:40:03

vale, ves que no da fallo, y el transform back 01:40:05

esto no siempre es 01:40:07

tal cual te lo estoy diciendo, mira de hecho 01:40:09

mira un ejemplo, transform punto back 01:40:11

no existe, pero si existe 01:40:13

forward, vale, en ese caso 01:40:15

si quisiéramos hacer lo mismo, ahí tenemos que hacer la solución 01:40:17

del menos, vale, para que veas que a veces 01:40:19

es que hay que buscar las vueltas 01:40:21

ahora, cuando yo lance el juego 01:40:23

en todo momento va a aplicar fuerzas 01:40:25

pero va a intentar hacerlas con respecto 01:40:27

a los ejes, es verdad 01:40:29

que como es un objeto 01:40:31

redondo, si no lo puedo hacer 01:40:33

con el cubo, ahora si no otra vez 01:40:35

vale, pero ahora si está aplicando las fuerzas 01:40:37

o lo está intentando en relación a los ejes locales 01:40:39

vale, al 01:40:41

esto es fácil de entender o de asimilar 01:40:43

porque está en todo momento 01:40:45

aplicando la fuerza en relación al 01:40:47

transform, a la situación del transform 01:40:49

el transform forward será 01:40:51

en relación a qué rotación tiene 01:40:53

vale, de hecho si me pongo aquí 01:40:55

en workspace 01:40:59

vale, eso, a veces 01:41:01

este transform forward funciona así 01:41:03

y a veces no, vale, pero es como una 01:41:05

regla que existe, vamos, mira 01:41:07

lo voy a hacer en el cubo, le voy a 01:41:09

voy a quitar la bola, voy a poner el cubo 01:41:11

que se vea 01:41:13

y le voy a poner el 01:41:15

mismo script que estoy poniendo a la bola 01:41:17

que a ver como se llamaba, de las fuerzas que es el player 01:41:19

manager, el player manager 01:41:21

lo aplico aquí 01:41:23

vale, y ahora 01:41:25

es este objeto el que tiene la 01:41:27

fuerza, vale, cuando 01:41:29

cuando le das 01:41:31

cuando le doy para adelante 01:41:33

va hacia el adelante, no, del 01:41:35

objeto, espera que le estoy dando mucha fuerza 01:41:37

le voy a bajar un poco para este ejemplo 01:41:39

le voy a dar fuerza 01:41:41

a mi, no, un tercio 01:41:43

y aquí 20, a ver que tal 01:41:45

va así 01:41:47

vale 01:41:49

le doy, vale 01:41:51

y se va moviendo hacia adelante 01:41:53

ahora le da muy poca fuerza, a ver, perdonad 01:41:55

esto es prueba 01:41:57

y error, es decir, es ir variando los 01:41:59

valores para ir viendo cual funciona 01:42:01

bien, le doy 01:42:03

fuerza, vale, y se va moviendo 01:42:05

vale, veréis 01:42:07

que yo le doy una vez 01:42:09

vale, e intenta ir 01:42:11

hacia adelante y va hacia adelante y se lanza 01:42:13

para atrás, pero aunque yo le de más para adelante 01:42:15

como ahora está, fijaos 01:42:17

eh 01:42:19

a ver, un segundo, que se ha ido 01:42:21

a cuenca, ahora bajará 01:42:23

ahora, cuando yo le doy para adelante 01:42:25

como está mirando hacia el suelo, vuelvo a darle 01:42:27

fijaos en la línea azul del propio objeto 01:42:29

el propio objeto, su forward es hacia allí 01:42:31

hacia el fondo, yo le doy una fuerza 01:42:33

hacia adelante, y ahora sigo dando hacia adelante 01:42:35

y está empujando hacia abajo 01:42:37

digo, leche, claro 01:42:39

la fuerza ya no es con respecto al mundo 01:42:41

si le doy a la S hacia atrás 01:42:43

lo que hace es, aunque se le aplica una fuerza muy 01:42:45

vasta, lo que hace 01:42:47

es, cuando le doy atrás es 01:42:49

saltar, no va hacia atrás 01:42:51

a nivel del mundo, sino que 01:42:53

pues placa y va hacia 01:42:55

atrás que tiene en relación a sus ejes 01:42:57

si yo cambiara esto otra vez 01:42:59

a vector 3 01:43:01

vale, que es con respecto al mundo 01:43:03

vector 3 y 01:43:05

vector 3 01:43:07

forward, vale 01:43:09

vais a ver que ahora el comportamiento 01:43:11

ha variado ligeramente, y es a 01:43:13

diferencia de, si os acordáis de la 01:43:15

práctica 2, que el translate tenía 01:43:17

un segundo parámetro, un segundo argumento que era 01:43:19

el space world 01:43:21

el space self 01:43:23

vale, aquí 01:43:25

pues se gestiona de otra forma, ahora 01:43:27

fijaos, cojo el cubo 01:43:29

voy al cubo, vale 01:43:31

y voy a poner el shading que se vea todo 01:43:33

vale, que antes lo he quitado, bueno 01:43:35

voy al juego, le doy hacia adelante, se mueve para adelante 01:43:37

le sigo dando hacia adelante 01:43:39

y va hacia adelante independientemente 01:43:41

ya le he dado muy fuerte, independientemente 01:43:43

de donde esté mirando las coordenadas 01:43:45

del propio objeto 01:43:47

vale, y por eso yo le estoy dando 01:43:49

muy fuerte, vale, pero va hacia adelante 01:43:51

y hacia atrás, y da igual 01:43:53

que el 01:43:55

mundo, es decir, que el objeto esté mirando hacia un lado 01:43:57

o hacia otro, vale, que 01:43:59

aquí habría que darle más peso al cubo 01:44:01

vale, porque parece que 01:44:03

está hecho de viento, un poquito de 01:44:05

resistencia, vale, para que se mueva un poco más 01:44:07

cuando cambie la masa y 01:44:09

el drag, atención porque 01:44:11

también habrá que darle más o menos fuerza, vale 01:44:13

porque si pesa mucho, a ver voy a bajarlo 01:44:15

vale, esto se puede en vivo 01:44:17

ir comprobando cuánto 01:44:19

de fuerza, es decir, los propios 01:44:21

valores se pueden ir ajustando en vivo 01:44:23

para ir viendo qué valores nos interesan 01:44:25

a ver, joe 01:44:27

a ver, voy a bajarle la masa mucho 01:44:29

ahí ya, ahora me he pasado 01:44:31

vale, que ojo, que esto para el testeo 01:44:33

está bien, pero si decimos, ah pues 0,23 01:44:35

es el valor, guardarlo en la memoria 01:44:37

porque cuando dejemos de dar a reproducir 01:44:39

vuelve a los valores que tenía antes de reproducir 01:44:41

ahora es cuando podríamos poner 0,23 01:44:43

vale, que esto ya lo expliqué también 01:44:45

un día, pero es importante 01:44:47

entonces, creo que te he solucionado 01:44:49

vamos, te he respondido 01:44:51

a la duda, no, de 01:44:53

que en vector 3 si se refiere al mundo 01:44:55

y si quisieras que no fuera al mundo 01:44:57

habría que hacerlo a través del transform 01:44:59

a ver, que no sé si 01:45:01

tal 01:45:03

resuelta la duda un poco 01:45:05

vale 01:45:07

estoy dando muchos rodeos 01:45:09

por temas muy interesantes y que me interesan mucho 01:45:11

de cara a siguientes prácticas, vamos a ir 01:45:13

un poco más al grano, de hecho la tutoría 01:45:15

debería durar hasta ahora, pero 01:45:17

voy a estar un poquillo más 01:45:19

el cambio de escena 01:45:21

vale 01:45:23

voy a hacer lo mismo de antes 01:45:25

como ya he explicado 01:45:27

como funcionan 01:45:29

los 01:45:31

los 01:45:33

colliders, los triggers, etc 01:45:35

voy a ir al que tenía preparado, que voy a ir un poco más rápido 01:45:37

y vuelvo a poner 01:45:39

vale, reinicio me lo cargo 01:45:41

que es el que habíamos hecho para esto 01:45:43

y pongo precipicio, que es el mismo 01:45:45

comportamiento de antes, es un objeto 01:45:47

vacío de visibilidad, no tiene ningún componente 01:45:49

para visibilizar nada 01:45:51

tiene un boss collider como un trigger 01:45:53

para que cuando se meta la bola 01:45:55

pues a ver que tenemos en el script 01:45:57

vamos allá, tenemos un 01:45:59

onTriggerEnter 01:46:01

que va a desencadenar esto 01:46:03

vale, varias cosas 01:46:05

la gestión de escenas 01:46:07

se ve en el tema 4, que ya tenéis abierto 01:46:09

hace un tiempo, en la primera parte 01:46:11

vale, entonces, aunque en la tarea 01:46:13

ya se dan las pautas para ver 01:46:15

cómo funciona esto 01:46:17

está más desarrollado en el tema 4 01:46:19

por si queréis leerlo y volver aquí 01:46:21

importante, para cuando vayamos a 01:46:23

recurrir a algo relacionado con la gestión 01:46:25

de escenas, vale, que es que 01:46:27

habrá ciertos métodos 01:46:29

como este de aquí, que es 01:46:31

funciona a través de esta clase 01:46:33

llamada SceneManager, como este que 01:46:35

activa 01:46:37

Scene, etc, vale 01:46:39

tenemos que poner una biblioteca 01:46:41

en esta sección de Usings, que es lo que hay 01:46:43

al principio, que es una biblioteca 01:46:45

que carga otra posibilidad de clases 01:46:47

esto también ya lo vimos en un momento, si yo por ejemplo 01:46:49

comentara esta línea 01:46:51

me daría error, porque hay 01:46:53

comandos e instrucciones que no se pueden 01:46:55

ejecutar, porque no se han programado 01:46:57

previamente y estas palabras clave 01:46:59

no aluden a nada, entonces 01:47:01

siempre que vayamos a hacer gestión de escena 01:47:03

esto hay que aprendérselo de memorieta 01:47:05

hay que usar este, esta librería 01:47:07

hay que implementarla en este código, vale 01:47:09

luego, en este script 01:47:11

que tengo puesto en ese 01:47:13

Collider Trigger, vale, no va a ejecutar 01:47:15

nada en tiempo de ejecución, no hay nada 01:47:17

relacionado con 01:47:19

el Start, ni el Update, ni el 01:47:21

Late Update, ni nada, yo quiero que se 01:47:23

ejecute solo en el momento que haya 01:47:25

un OnTrigger de un elemento que 01:47:27

cruza ese área 01:47:29

definida por el Collider, vale 01:47:31

aquí 01:47:33

era una de las cosas que quería explicar hoy 01:47:35

pero lo dejaré para el siguiente día, pero 01:47:37

importante, cuando veáis un método 01:47:39

que entre sus paréntesis, al declarar el 01:47:41

método, ve, aquí estamos declarando un método 01:47:43

void, vale, que recordad 01:47:45

que eran esos métodos que dentro se metía código 01:47:47

que pasaba por ese código y se 01:47:49

ejecutaba, vale 01:47:51

ejecuta esto y cuando veáis entre paréntesis 01:47:53

un tipo 01:47:55

de variable, vale, aquí al final lo que 01:47:57

se está haciendo es declarar una variable, vale 01:47:59

que vamos a usar dentro 01:48:01

de este script, cuando declaramos una 01:48:03

variable de este tipo, vale 01:48:05

vamos a poder afectar 01:48:07

o cambiar 01:48:09

mediante parámetros 01:48:11

estos 01:48:13

los acciones también 01:48:15

ahora mismo si marco este other 01:48:17

vale, veis que aquí se está haciendo 01:48:19

una referencia a other también aquí 01:48:21

vale, básicamente de manera muy 01:48:23

simplificada 01:48:25

lo que metemos como, lo que se llaman 01:48:27

parámetros de un 01:48:29

trigger, vale, es 01:48:31

en el caso de un trigger 01:48:33

es que estamos aludiendo a que el otro 01:48:35

objeto que ha chocado con nosotros 01:48:37

vamos a poder hacer acciones con él 01:48:39

por ejemplo en este caso 01:48:41

tenemos el precipicio, ese 01:48:43

Collider esperando a que choque algo 01:48:45

y claro, en ciertos momentos 01:48:47

no puede interesar, vale, pero si choca 01:48:49

la plataforma porque se cae 01:48:51

no quiero reiniciar de nivel 01:48:53

quiero que se reinicie solo en el momento que sea 01:48:55

la bola, por ejemplo 01:48:57

vale, para eso tendremos que recurrir 01:48:59

a esta variable que se genera cada vez que 01:49:01

se ejecuta un trigger, vale 01:49:03

ahora mismo 01:49:05

de cara a la tarea 01:49:07

sería mejor que siguiera por aquí 01:49:09

pero hay una cosa que voy a explicar 01:49:11

antes, un poco 01:49:13

antes, vale, cuando en 01:49:15

voy a poner aquí un start 01:49:17

simplemente por tenerlo aquí preparado 01:49:19

cuando hacíamos un instantiate 01:49:21

vale, recordad como 01:49:23

funcionaba, aquí lo tenemos 01:49:25

cuando hacíamos un instantiate 01:49:27

recordad que había lo que se llamaba 01:49:29

sobrecargas, vale, y entre los paréntesis 01:49:31

podían aparecer 01:49:33

distintos tipos de variable 01:49:35

que había que introducir junto aquí un nombre de 01:49:37

referencia de variable, veis que 01:49:39

se parece ligeramente a esto que tenemos aquí 01:49:41

vale, esto es un método 01:49:43

que ya alguien, vale, en una de estas librerías 01:49:45

que tenemos aquí, ha generado 01:49:47

un método llamado instantiate 01:49:49

vale, y al declararlo como estamos 01:49:51

haciendo aquí, vale 01:49:53

se puso entre paréntesis 01:49:55

tipos de variables 01:49:57

vale, entonces cada vez que estamos 01:49:59

usando un método 01:50:01

vale, todas estas sobrecargas 01:50:03

son que alguien ha dicho, oye 01:50:05

este método 01:50:07

se pueden pasar parámetros 01:50:09

a través de los paréntesis 01:50:11

y esos parámetros luego se usan dentro 01:50:13

del método 01:50:15

vale, para explicar esto 01:50:17

estoy aquí preparado, voy a salir un poco 01:50:19

de tema, pero es 01:50:21

fundamental para ir entendiendo las siguientes 01:50:23

cosas, vale 01:50:25

voy a ir a un nivel de prueba 01:50:27

vale, que es generado aquí, que está vacío 01:50:29

voy a guardar esto, creo que sí 01:50:31

vale, y he hecho 01:50:33

un, esto es simplemente a nivel teórico 01:50:35

vale, estaba en el tema cero 01:50:37

que es crear 01:50:39

métodos, igual que hacíamos 01:50:41

el de saltar o el de check limits 01:50:43

que os expliqué un día en el tema 01:50:45

en la tarea dos, vale 01:50:47

vamos a, voy a hacer un game object vacío 01:50:49

con un script dentro 01:50:51

que sirva para testear lo que 01:50:53

estamos haciendo en este 01:50:55

en un script que he creado para 01:50:57

explicaros esto, vale 01:50:59

a ver 01:51:01

voy a empezar por el principio 01:51:05

de esto, porque entiendo 01:51:07

que esto es importante que sepáis ahora 01:51:09

bueno, aquí tengo uno creado, pero lo voy a crear de cero 01:51:13

realmente, voy a borrar 01:51:15

este componente y voy a generar 01:51:17

un script 01:51:19

que se llame 01:51:21

probando 01:51:23

a ver, perdonad, recordad 01:51:25

hacer bien la nomenclatura, probando 01:51:27

métodos 01:51:29

return 01:51:31

vale, vamos a llamar así 01:51:33

cuando generamos un método 01:51:35

y aquí lo tengo 01:51:37

y lo voy a poner 01:51:39

a ver, que aquí se me están empezando a acumular un montón de cosas 01:51:41

cuando 01:51:43

tenemos este método 01:51:45

a ver, dónde está 01:51:47

este no es 01:51:49

este no es 01:51:51

este no es 01:51:53

este método 01:51:55

recién creado 01:51:57

no sé por qué aquí se me están juntando todos 01:51:59

vale 01:52:01

recordad que nosotros 01:52:03

podíamos decir, vale, que en el start 01:52:05

se ejecute un método que se llamara 01:52:07

que queramos nosotros 01:52:09

enviar mensaje 01:52:11

o decir algo 01:52:13

vale, y ya vimos 01:52:15

que declarábamos con este void 01:52:17

un método 01:52:19

que al final lo que hace es ejecutar 01:52:21

todo lo que hay adentro 01:52:23

sin hacer nada más, es decir 01:52:25

si yo ahora mismo dentro de este método 01:52:27

vale, aquí está 01:52:29

le digo 01:52:31

debug log 01:52:33

di algo 01:52:35

vale 01:52:37

di algo 01:52:39

punto coma, vale, yo cuando le diga en el start 01:52:41

decir algo 01:52:43

con los paréntesis que definen 01:52:45

que es un método, vale 01:52:47

yo cuando lance el juego 01:52:49

se va a meter aquí, es decir, en el start va a decir 01:52:51

eh, aquí hay un método de decir algo, que se ejecute 01:52:53

pues dentro de ese script 01:52:55

hay un método que hemos declarado que es decir algo 01:52:57

y se ejecuta, verdad, entonces ahora 01:52:59

cuando lance el juego 01:53:01

cancel, no sé por qué se ha puesto eso 01:53:03

cuando le de al play 01:53:05

en la consola 01:53:07

a ver, por qué no se ha aplicado 01:53:09

no le he puesto el script 01:53:11

atención que si no ponemos el script 01:53:13

ahora, al lanzar el juego 01:53:15

debe ser que no guarda 01:53:17

no 01:53:19

mmm 01:53:21

a ver, que tengo aquí un 01:53:23

jaleo de scripts ya creados 01:53:25

a ver, voy a cerrar ciertas cosas 01:53:29

que tengo aquí abiertas 01:53:31

ah, perdón 01:53:33

esto, nada 01:53:35

espera, que estoy con otro monitor, un segundo 01:53:37

vale 01:53:39

y ahora, probando método de return, vale 01:53:41

tengo esto guardado 01:53:43

tengo probando método de return, eso 01:53:45

cuando empieza el juego le digo, eh, di algo 01:53:47

y ahora al ejecutarlo 01:53:49

en la consola, debería decir 01:53:51

di algo, ahí está, vale 01:53:53

que lo mismo, por repaso 01:53:55

el di algo 01:53:57

si yo le digo 01:53:59

que lo llame en vez de 01:54:01

en el start, en el update, ahora en cada 01:54:03

fotograma va a meterse en 01:54:05

decir algo y va a ejecutar, por tanto 01:54:07

cuando ahora lo ejecute, va a ver un di algo 01:54:09

en cada frame 01:54:11

que realice, vale, hasta aquí entiendo 01:54:13

que esto, ya lo expliqué otro día 01:54:15

lo tenemos claro, si, si no 01:54:17

decidme, que esto es importante 01:54:19

que lo tengamos claro, porque voy a ir un paso más allá ahora 01:54:21

esto más o menos claro, vale 01:54:27

hay 01:54:29

formas de declarar los 01:54:31

métodos, vale 01:54:33

que ponen en juego estos paréntesis que hasta ahora 01:54:35

decíamos, porque aquí hay paréntesis tantas veces 01:54:37

vale, esto 01:54:39

básicamente que vamos a hacer, por ejemplo, cuando el 01:54:41

programador definiera 01:54:43

el método instantiate 01:54:45

que nosotros podemos acceder en cualquier momento 01:54:47

él declaró este método 01:54:49

y dentro de estos paréntesis puso diferentes 01:54:51

cosas para que luego nosotros 01:54:53

supiéramos que meter para hacer 01:54:55

las acciones, entonces yo por ejemplo 01:54:57

en cierto 01:54:59

momento, vale, voy a hacer un 01:55:01

ejemplo así rápido, ahora 01:55:03

vemos más, digo que en el start se ejecute 01:55:05

decir algo, y puedo decir, oye 01:55:07

aquí, vale 01:55:09

habrá que decir que haya 01:55:11

un mensaje de texto 01:55:13

que sea el que muestre, lo voy a hacer 01:55:15

rápido y vais a decir que estás haciendo 01:55:17

pero si yo ahora pongo aquí 01:55:19

ahora lo explico bien 01:55:21

Daniel, vale 01:55:25

vais a ver, vale, vamos a ver la lógica 01:55:27

de lo que está pasando, en el start 01:55:29

estamos llamando al método a decir algo 01:55:31

pero estamos introduciendo un string 01:55:33

que es Daniel, no 01:55:35

entonces aquí básicamente estamos dando 01:55:37

una instrucción para que cuando 01:55:39

se ejecute este método 01:55:41

coja lo que hayamos 01:55:43

enviado al llamar al 01:55:45

método, vale, que tiene que concordar 01:55:47

con tipo 01:55:49

y con tipo de variable, vale 01:55:51

y va a meter este mensaje 01:55:53

luego en la instrucción que hagamos 01:55:55

sé que ahora mismo estaréis 01:55:57

diciendo, que me está contando este chico 01:55:59

quiero que veáis, vale, ahora 01:56:01

vemos más ejemplos, quiero que veáis 01:56:03

que a partir de este string mensaje 01:56:05

vale, el debug log va a devolver 01:56:07

lo que le haya llegado por 01:56:09

los paréntesis, entonces 01:56:11

estamos haciendo una especie de puerta 01:56:13

entre este decir algo 01:56:15

que le metemos ya un mensaje aquí 01:56:17

que va a recibir a través de la declaración 01:56:19

para luego plasmarlo aquí que es la orden 01:56:21

directa de, oye en el debug log enséame 01:56:23

un mensaje, a ver 01:56:25

simplemente por ver si funciona 01:56:27

yo cuando arranco el juego, esperad 01:56:29

porque no he guardado, siempre me pasa lo mismo 01:56:31

a ver un segundo 01:56:33

aquí, vale, guardo 01:56:35

y ahora sí que ejecuto 01:56:37

vais a ver que sale Daniel una vez 01:56:39

en el start, vale 01:56:41

esto es el principio de que yo 01:56:43

cuando 01:56:45

declaramos un método como el instantiate 01:56:47

se vayan generando 01:56:49

esas sobrecargas que decíamos, vale 01:56:51

entre paréntesis 01:56:53

instantiate, vale, vais a ver 01:56:55

que entre estos paréntesis se pueden meter 01:56:57

un montón de tipos de variable 01:56:59

y de distinto tipo 01:57:01

yo por ejemplo imaginaos 01:57:03

que ahora en vez 01:57:05

de poner aquí un 01:57:07

string mensaje le digo, oye 01:57:09

quiero que lo que reciba por aquí sea 01:57:11

un número, vale, y voy a poner que sea 01:57:13

una variable de tipo int 01:57:15

que sea 01:57:17

cuyo número 01:57:19

es valor 01:57:21

a reflejar, por poner un 01:57:23

nombre que no sea número 01:57:25

para que quede más descriptivo 01:57:27

vale, ahora mismo salen varios fallos 01:57:29

porque al llamar a este método 01:57:31

vale, le estamos dando 01:57:33

este método está declarado aquí, le estamos 01:57:35

dando un valor, vale 01:57:37

esto digamos que es una puerta, lo que hay entre paréntesis 01:57:39

es una puerta 01:57:41

entre la declaración y cuando 01:57:43

ya ejecutamos este método 01:57:45

está recibiendo un valor que 01:57:47

no es el del tipo que estamos 01:57:49

declarando, vale 01:57:51

aquí lo que estamos recibiendo es 01:57:53

un string y aquí sólo caben ahora mismo 01:57:55

variables de tipo int, entonces yo por ejemplo 01:57:57

si le digo 5, aquí ya 01:57:59

este fallo deja de 01:58:01

de mostrarse 01:58:03

y mensaje como no lo hemos declarado aquí 01:58:05

no está algo que esté declarado 01:58:07

en la variable, pues no enseña nada 01:58:09

da fallo, aquí habrá que decir que enseñe 01:58:11

valor a reflejar 01:58:13

vale y fijaos 01:58:15

ahora en la jugada 01:58:17

he dicho al arrancar 01:58:19

ejecútate el decir algo y pasa el valor 01:58:21

5, vale, pues se va a ejecutar 01:58:23

decir algo y aquí se mete el 01:58:25

valor 5, vale, digamos que 01:58:27

crea una nueva variable que se llamará 01:58:29

valor a reflejar que está guardando el 5 01:58:31

y dentro de este método 01:58:33

aquí es el número que ha 01:58:35

pasado anteriormente, aquí se ha guardado un 5 01:58:37

y aquí se enseñará un 5 01:58:39

vale, entonces 01:58:41

a ver, le doy a consola y le doy al play 01:58:43

y me enseña 01:58:45

el 5 01:58:47

esto, ¿para qué se usa? 01:58:49

pues por ejemplo, imaginaos 01:58:51

voy a ir más allá, que 01:58:53

tengo un método 01:58:55

que hace operaciones matemáticas 01:58:57

vale, entonces 01:58:59

en vez de decir 01:59:01

que me devuelva la nada, es decir 01:59:03

que pase por aquí y se ejecute, podemos decir 01:59:05

no, este método cuando termina 01:59:07

de ejecutarse, igual que cuando declarábamos 01:59:09

algo 01:59:11

a ver, perdonad 01:59:13

vale, sí, voy a 01:59:15

dejar esto así 01:59:17

y esto lo borro 01:59:19

imaginaos, bueno no 01:59:21

lo dejo ahí, vale, tengo un método 01:59:23

que va a tener que devolver algo 01:59:25

no es el void, el vacío 01:59:27

que había en el anterior método, sino que aquí va a haber 01:59:29

un número, es decir 01:59:31

estamos creando aquí un método que sirve 01:59:33

para que devuelva un número 01:59:35

vale, cuando yo haga la ejecución, cuando llame 01:59:37

en algún momento de ejecución a este método 01:59:39

él no va a ejecutar lo que está aquí 01:59:41

dentro, sino que va a devolver un número 01:59:43

en este caso, vamos a ver 01:59:45

ejemplos, que esto hasta que no se den ejemplos 01:59:47

vale, y por ejemplo 01:59:49

voy a quitar el argumento en este caso 01:59:51

y voy a decir 01:59:53

lo que no sé es por qué me está dando 01:59:55

este fallo, a ver un segundo 01:59:57

decir algo tal 01:59:59

vale, ya sé por qué es 02:00:01

vale, tenemos aquí un int y un 02:00:03

decir algo, entonces nosotros vamos a 02:00:05

decir, vamos a crear aquí una variable, por ejemplo 02:00:07

se llama float, número a 02:00:09

5, vale 02:00:11

y luego otro float, que lo declaro 02:00:13

dentro, vale, y al declararlo 02:00:15

dentro con el tipo de variable, luego no se 02:00:17

podrá usar aquí, pero dentro de este 02:00:19

método aquí especificado, sí 02:00:21

un número b 02:00:23

que es 12, vale 02:00:25

y luego voy a hacer otro 02:00:27

variable, ahora vemos más 02:00:29

por qué estamos 02:00:31

haciendo esto, vale, que va a ser 02:00:33

número a, esto ya vimos un 02:00:35

ejemplo de que hacía esto mismo, pero 02:00:37

en un método de tipo void, en otro día, vale 02:00:39

vamos a ir un paso más allá, para explicar 02:00:41

ciertas cosas, vale 02:00:43

si yo ahora mismo 02:00:45

ehmm 02:00:47

quiero ejecutar esta orden, vale 02:00:49

siempre 02:00:51

normalmente, siempre que hagamos un método 02:00:53

que tiene que devolver un valor 02:00:55

como un int aquí o una booleana, hay que 02:00:57

usar una palabra clave muy importante que se llama 02:00:59

return, devolver 02:01:01

vale, entonces 02:01:03

ehmm 02:01:05

return sirve para que cuando se ejecute lo 02:01:07

que hay aquí, vale, devuelva 02:01:09

un valor, entonces 02:01:11

por ejemplo, quiero que devuelvas lo que 02:01:13

se ha guardado en resultado 02:01:15

a ver, qué es lo que está dando 02:01:17

ehmm 02:01:19

return resultado, sí 02:01:21

ah, vale 02:01:23

bueno, aquí hay otro problema 02:01:25

que es que estamos usando números float 02:01:27

tiene que devolver una variable de tipo float 02:01:29

pero en realidad lo que tiene que devolver es un int 02:01:31

hay un problema de declaración de variables 02:01:33

habría que hacer que todo fuera ints 02:01:35

vale, esto perdonad que 02:01:37

es complicado además 02:01:39

vale, tenemos un método que tiene que devolver 02:01:41

un int, no, y 02:01:43

entonces aquí dentro lo que se está haciendo es 02:01:45

una suma, vale, que se guarda en este 02:01:47

esta variable resultado y dice vale 02:01:49

aquí devuélveme resultado 02:01:51

eso significa que cuando 02:01:53

yo 02:01:55

llame a este método decir 02:01:57

algo, esto 02:01:59

pasa a valer 12 02:02:01

es decir, si yo ahora mismo 02:02:03

hiciera un debug 02:02:05

punto log 02:02:07

de el método 02:02:09

decir algo, vale, es decir 02:02:11

el debug log que enseñe lo que devuelve 02:02:13

este, esta variable, vale 02:02:15

esta variable lo que hace es meterse 02:02:17

aquí y decir, oye de esta variable lo que tiene 02:02:19

que salir es un 02:02:21

valor de tipo entero, vale 02:02:23

aquí estamos haciendo diferentes 02:02:25

operaciones y siempre 02:02:27

ya os he dicho que no sea un void 02:02:29

siempre debería, vale, esto tiene excepciones 02:02:31

vale, pero en principio debería 02:02:33

tener la palabra clave return para decir 02:02:35

vale, esto quiero que devuelva 02:02:37

este valor, vale, esta variable 02:02:39

y como resultado 02:02:41

vale, 12 más 5, vale 02:02:43

pues lo que va a devolver aquí en el debug log al comenzar 02:02:45

va a ser un 17 02:02:47

a ver, vale, 17 02:02:49

esto diréis 02:02:51

y por qué no, como hicimos el otro 02:02:53

día, hacemos las operaciones aquí y hacemos el debug 02:02:55

log con las operaciones aquí 02:02:57

por diferentes cosas, primero porque 02:02:59

nos puede interesar que haya un método 02:03:01

como por ejemplo el instanced 02:03:03

que nos sirva para llamarlo en cualquier momento 02:03:05

sin tener que hacer todo este 02:03:07

código que tenemos aquí 02:03:09

vale, y también porque nos sirve 02:03:11

para guardarlo en librerías como el 02:03:13

instanced por ejemplo y usarlo en más 02:03:15

momentos del código, vale, entonces 02:03:17

es una forma de 02:03:19

agrupar, vale, y de hecho para que sea más 02:03:21

descriptivo voy a decir que esto se llame 02:03:23

sumar números, vale 02:03:25

y el método que se llame sumar números para que sea más descriptivo 02:03:27

sumar números 02:03:29

vale 02:03:31

ahora mismo esto tiene que devolver 02:03:33

un valor numérico 02:03:35

devuelve este 02:03:37

17 que es el resultado de todo 02:03:39

esto que hemos estado haciendo, hasta aquí 02:03:41

más o menos me seguís 02:03:43

perdona que sé que es un lío 02:03:45

pero por eso, preguntadme porfa 02:03:47

vale, entonces 02:03:49

la clave es que nosotros ya que 02:03:51

hemos declarado este método 02:03:53

y si usamos 02:03:55

el poder de los paréntesis ahora 02:03:57

podemos usar este método muchas veces 02:03:59

porque se llama igual, pero cada vez 02:04:01

que lo llamemos con todas las operaciones 02:04:03

que tiene dentro, que lo haga 02:04:05

en base a lo que le pasemos por paréntesis 02:04:07

que es esto que 02:04:09

vamos a configurar ahora, si yo 02:04:11

por ejemplo a este int sumar número 02:04:13

le hubiera dicho que haya otro int 02:04:15

dentro de los paréntesis de tipo 02:04:17

que sea número 02:04:19

aportado, yo que sé 02:04:21

vale, yo aquí en cierto 02:04:23

momento lo que podría decirle 02:04:25

oye, en esta 02:04:27

ocasión, bueno en vez de un 5 voy a poner otro 02:04:29

un 8, vale, sumar números 02:04:31

vale, lo voy a llamar, pero con 02:04:33

un 8 aquí entre los paréntesis, vale, va aquí 02:04:35

y dice a ver 02:04:37

voy a ejecutar este método 02:04:39

que lo que tiene que devolver es un valor numérico 02:04:41

entero además, vale 02:04:43

y voy a capturar lo que me llegue 02:04:45

por el paréntesis, ahora mismo al ejecutar 02:04:47

este 02:04:49

método, aquí vale 8 02:04:51

y que es la gracia de esto, que yo 02:04:53

aquí puedo decir que 02:04:55

ese 8 sea número aportado 02:04:57

vale, de hecho mira, directamente 02:04:59

no hace falta ni que declare número a 02:05:01

puedo decir que número aportado 02:05:03

sea un número, vale 02:05:07

que se sume con el otro, ahora mismo lo que 02:05:09

estamos haciendo es que mediante el 02:05:11

número que pongamos aquí 02:05:13

se ejecute lo que hay adentro y sea 02:05:15

este que hemos metido por aquí, el 8 02:05:17

más 12, 20 02:05:19

entonces, ahora mismo, por ejemplo, yo le doy 02:05:21

al play y me devuelve 20 02:05:23

pero yo este 02:05:25

este mismo método, vale 02:05:27

le puedo decir que 02:05:29

aquí 02:05:31

sean 20, pero también puedo hacer otro 02:05:33

luego, llamando al mismo método 02:05:35

que sea 02:05:37

pues yo que sé, 14, que entonces devolvería 02:05:39

bueno, voy a poner un número más pequeño 02:05:41

un 2, vale 02:05:43

que entonces este debug log lo que 02:05:45

devolvería es un 14, vale 02:05:47

porque aquí le estamos pasando un 2 02:05:49

estamos llamando a la instrucción otra vez 02:05:51

pero con otro valor 02:05:53

como argumento, entonces vais a ver 02:05:55

que va a reflejar en una ocasión 02:05:57

y se está ejecutando 02:05:59

exactamente el mismo método, pero 02:06:01

según los argumentos que estemos 02:06:03

aportando 02:06:05

el interior, la operación que hace 02:06:07

es distinta, entonces va a devolver una línea 02:06:09

que va a devolver 20, porque es 8 02:06:11

más 12, 20, y en la siguiente 02:06:13

va a devolver 14, vale 02:06:15

entonces yo ejecuto para que veáis que es cierto 02:06:17

y yo también tenerlo claro 02:06:19

20 y 14, vale, entonces ahora este método 02:06:21

sumar números, yo lo puedo 02:06:23

aplicar en cualquier momento del código 02:06:25

incluso aquí puedo decir 02:06:27

incluso yo puedo hacer 02:06:31

a ver 02:06:33

aquí un debug log 02:06:35

directamente, también que sea 02:06:37

sumar números 02:06:39

y en esta ocasión 02:06:41

quiero que sea un 7, vale 02:06:43

y además 02:06:45

a lo que devuelva le sumamos 5 02:06:47

vale, vais a ver 02:06:49

estamos usando el mismo método varias veces 02:06:51

igual que el instanced, cada vez que lo llamemos 02:06:53

pues vamos a ir apelando a un distinto prefab 02:06:55

o distintas cosas, vale 02:06:57

y aquí lo que va a hacer es 02:06:59

sumar 7, esto lo que va a devolver es 02:07:01

7 más 12 02:07:03

19, y luego más 5 02:07:05

19 más 5, 24 02:07:07

vais a ver que va a ver 02:07:09

estas dos líneas que hacen esta operación y luego en el update 02:07:11

fotograma tras fotograma 02:07:13

pues se va a mostrar 24 02:07:15

vale, a ver guardo primero 02:07:17

importante, guardo 02:07:19

y le doy al play 02:07:21

veis 02:07:23

bueno detengo para que veáis 02:07:25

que las dos primeras se han ejecutado en el 02:07:27

start y la siguiente ya es 24 02:07:29

en todo momento, entonces veis que en todo momento 02:07:31

estamos operando 02:07:33

con números que pasamos 02:07:35

a través de un método, que ojo esto puede 02:07:37

ser un número o como hemos hecho antes 02:07:39

un string, solo hay que preocuparse de que lo que 02:07:41

está entre los paréntesis tiene que 02:07:43

coincidir con lo que tengamos aquí 02:07:45

declarado, y es más 02:07:47

nosotros podemos tener 02:07:49

un método que 02:07:51

por ejemplo, ahora voy a hacer otro 02:07:53

método que sea 02:07:55

se llame igual, aunque no vaya a hacer eso 02:07:57

que se llame igual sumar números 02:07:59

podemos declarar varios métodos con el mismo nombre 02:08:01

y este sea de tipo string 02:08:03

mensaje 02:08:05

mensaje 02:08:07

cuando lo termine y lo veamos 02:08:09

lo entenderéis mejor, que sé que ahora 02:08:11

seguramente digáis otra vez 02:08:13

que hace este chico 02:08:15

a ver 02:08:17

vale 02:08:19

vale 02:08:21

veis que ahora estoy declarando 02:08:23

para tenerlo ya en cuenta 02:08:25

otro método que no es void 02:08:27

y cuando no es void no es que ejecute lo 02:08:29

dentro, sino que va a devolver algo que es un 02:08:31

string, como os he 02:08:33

dicho antes, siempre que pongamos 02:08:35

o casi siempre que pongamos algo 02:08:37

que tenga un tipo de método 02:08:41

que tenga que 02:08:43

devolver algo diferente a un void, hay que poner 02:08:45

la instrucción return, hasta que no se ponga 02:08:47

va a dar error 02:08:49

porque no saben en que momento tiene que 02:08:51

devolver un valor, entonces ahora mismo 02:08:53

podemos decir 02:08:55

que cuando, a ver 02:08:59

por ejemplo, perdonad 02:09:01

lo primero, veis que hemos declarado variables 02:09:03

y ahora mismo 02:09:05

las dos 02:09:07

están aquí esperando 02:09:09

perdonad, voy a poner un ejemplo 02:09:11

es que si no pongo el ejemplo 02:09:13

voy a poner un string 02:09:15

que sea 02:09:17

mensaje más 02:09:19

he dicho 02:09:21

vale 02:09:25

y entonces, string 02:09:27

habrá que decirle frase 02:09:29

completa 02:09:31

y aquí lo que quiero que vuelva es 02:09:33

frase completa 02:09:35

vale, entonces 02:09:37

ahora mismo lo que podemos hacer 02:09:39

con sumar números, que veis que se llama igual 02:09:41

vale, si yo 02:09:43

voy a quitar este del update 02:09:45

para que no esté todo el rato 02:09:47

moviéndose, si yo ahora el debug log 02:09:49

lo que quiero que se muestre 02:09:51

es sumar números, pero 02:09:53

lo que le pasamos entre paréntesis 02:09:55

es un string 02:09:57

vale, lo que hará será 02:09:59

decir, ah vale, aquí no me está pasando 02:10:01

un int, así que voy a buscar 02:10:03

en el de string, vale, voy a decir 02:10:05

me llamo Daniel 02:10:07

a ver si funciona, porque creo que hay una cosa que igual 02:10:11

entra en conflicto, pero bueno, ahora lo vemos 02:10:13

vale, aparentemente 02:10:15

no hay fallo, que es lo que estamos haciendo, que en el update 02:10:17

siempre se muestra en consola 02:10:19

lo que devuelva este método 02:10:21

este método, vale, llama aquí 02:10:23

y empieza a decir, vale 02:10:25

hay algo entre los paréntesis, un argumento 02:10:27

me llamo Daniel, esto no cuadra con esto 02:10:29

porque es de distinto 02:10:31

tipo de variable, pero este 02:10:33

si cuadra porque es un string, entonces 02:10:35

voy a pasar el me llamo Daniel 02:10:37

a través de este paréntesis, vale 02:10:39

nos metemos aquí, y dice 02:10:41

vale, hay una variable 02:10:43

que he creado aquí dentro que se llama frase completa, que es 02:10:45

que cojo el mensaje que me haya 02:10:47

llegado por aquí, y aparte le añado 02:10:49

he dicho después, vale 02:10:51

y luego lo que devuelvo es 02:10:53

esa frase completa, vale, es decir 02:10:55

este método lo que devuelve es 02:10:57

esta frase completa que tenemos aquí 02:10:59

guardada, eso significa 02:11:01

que cuando yo ejecute este 02:11:03

método, va a devolver un 02:11:05

me llamo Daniel, he dicho 02:11:07

en cada fotograma, vamos a ver si es verdad 02:11:09

que igual hay un 02:11:11

pequeño problema, vale, veis 02:11:13

lo detengo para verlo 02:11:15

a mí en el start me ha hecho 20 02:11:17

14 y luego me llamo Daniel, he dicho 02:11:19

y fijaos 02:11:21

que yo en todo momento lo que estoy haciendo 02:11:23

es usar siempre 02:11:25

el mismo método, vale, es verdad que 02:11:27

lo lógico aquí sería poner otro nombre de método 02:11:29

porque, sí 02:11:31

para que sea más descriptivo como escribir frase o algo así 02:11:33

pero fijaos que me sirve para que 02:11:35

veáis que con un mismo método, un mismo nombre 02:11:37

luego según lo que vayamos pasando en 02:11:39

las 02:11:41

en los argumentos, esto que hay 02:11:43

entre paréntesis, pues se 02:11:45

llama a un método o a otro 02:11:47

ojo que pueden ser de distinto tipo también 02:11:49

el propio método, que luego devolverá 02:11:51

lo que le digamos, esto 02:11:53

básicamente cuando yo ahora pongo 02:11:55

en algún punto, vais a fijaros 02:11:57

que hemos creado lo que a veces 02:11:59

que así es como se programan muchas 02:12:01

cosas, vaya, cuando yo 02:12:03

hago un, quiero llamar a sumar números 02:12:05

y abro paréntesis, fijaos que yo 02:12:07

tengo dos sobrecargas, vale 02:12:09

tengo la de el número 02:12:11

aportado, que es la primera y luego 02:12:13

la segunda que es la del stream mensaje 02:12:15

y es la misma, vale 02:12:17

luego incluso se puede complicar más 02:12:19

que es, puedo hacer 02:12:21

otro 02:12:23

método que devuelva un int 02:12:25

vale, que se llama sumar números 02:12:27

y aparte 02:12:29

aunque se llame igual 02:12:31

lo que voy a hacer es que a través de los 02:12:33

argumentos, voy a meter 02:12:35

número aportado 02:12:37

doble, yo que sé, o segundo 02:12:39

vale, separando por comas 02:12:41

estos argumentos 02:12:43

vale, luego por ejemplo 02:12:45

en este 02:12:47

lo que puedo hacer es 02:12:49

decir, oye el segundo 02:12:51

valor que me hayan metido es el que uso 02:12:53

para la operación, número aportado 02:12:55

estoy poniendo nombres muy largos pero bueno 02:12:57

vale, que significa eso, que si en algún 02:12:59

momento yo hago aquí un 02:13:01

debug log o la operación que sea, ya os digo 02:13:03

que estoy usando los debug logs para verlo en consola 02:13:05

pero a lo mejor puede ser daño 02:13:07

y cuando se ejecuta daño aquí pasemos 02:13:09

cien de vida, cien, y la operación 02:13:11

que hace dentro es restarlo 02:13:13

a la vida que tiene ya el personaje 02:13:15

esto lo iremos viendo ya más adelante 02:13:17

pero ahora puedo decirle 02:13:19

cinco y separado por coma 02:13:21

siete, y esto os recordará un poco 02:13:23

a como se escribe, a ver un segundo 02:13:25

que está habiendo aquí un error 02:13:27

ah no, bueno, claro 02:13:29

perdonad, que es que primero habrá que poner que método es 02:13:31

sumar números y aquí 02:13:33

cinco coma siete 02:13:35

vale, no da ningún fallo 02:13:37

esto se parece un poco a cuando vamos dentro 02:13:39

de un instancy, de un rotate, de un add force 02:13:41

metiendo valores separados por 02:13:43

comas, por las sobrecargas 02:13:45

ahora mismo al llegar a este debug log 02:13:47

dice vale, tengo que ejecutar este 02:13:49

sumar números, y pasan dos argumentos 02:13:51

de tipo int los dos, empieza 02:13:53

este de aquí, se llama sumar números, sí 02:13:55

vale, pero solo tiene un argumento, este 02:13:57

no me interesa, así que paso al siguiente 02:13:59

este, a ver, tiene 02:14:01

dos separado por comas 02:14:03

que los dos son int, vale, pues es este 02:14:05

al que estoy llamando con esta línea 02:14:07

este saltar números 02:14:09

comprende que es este, y ya dentro dice 02:14:11

vale, voy a crear 02:14:13

aquí una variable llamada resultado 02:14:15

y voy a usar los números 02:14:17

que me estén llegando y en el mismo 02:14:19

orden que esté, vale, el orden es muy importante 02:14:21

el mismo orden que esté declarados 02:14:23

aquí, entonces, número aportado 02:14:25

se identifica con el cinco 02:14:27

y el siete se identifica con número aportado 02:14:29

segundo, que he hecho un int 02:14:31

que lo que hace es sumar el cinco 02:14:33

que le llega y el siete que le llega 02:14:35

dando como resultado 02:14:37

doce, por tanto en la 02:14:39

tercera línea del start 02:14:41

vale, de la consola 02:14:43

lo que va a poner es un 02:14:45

doce, veis 02:14:47

aquí está, así es como se crean los métodos 02:14:49

que tienen sobrecargas de hecho, vale 02:14:51

esto, cuando lo interioricéis 02:14:53

es súper poderoso porque podéis crear 02:14:55

vuestros propios métodos 02:14:57

vale 02:14:59

eh, que tal hasta aquí 02:15:01

esto me sirve para 02:15:03

hablaros de otras cosas otros 02:15:05

días, y 02:15:07

complicado 02:15:09

si, esta parte 02:15:11

tenéis que revisarla y probar 02:15:13

vosotros hacerlo, vale 02:15:15

esto me sirve, por lo que lo he explicado 02:15:17

porque cuando tenemos un on collision 02:15:19

a ver, vuelvo al 02:15:21

precipicio, si no me equivoco 02:15:23

aquí, por defecto 02:15:25

ya viene hecho, pero es un método 02:15:27

que dice vale on trigger, pero ya hay 02:15:29

una variable que le llega 02:15:31

al on trigger, aquí no 02:15:33

como hemos hecho hasta ahora, no es que 02:15:35

aunque exista este método, no es que aquí 02:15:37

digamos on trigger enter para llamarlo 02:15:39

es un método que ya está configurado 02:15:41

para que se ejecute directamente 02:15:43

vale, estará en alguna de estas librerías 02:15:45

vale, por eso sale automáticamente 02:15:47

pero 02:15:49

si que tiene la posibilidad de 02:15:51

un tipo de variable, tipo collider 02:15:53

vale, que es un tipo de variable que sirve 02:15:55

para identificar que es lo que 02:15:57

choca con este objeto, vale, que va a llamar other 02:15:59

es decir 02:16:01

simplificado, dentro del on trigger enter 02:16:03

si ponemos la palabra other 02:16:05

estamos refiriéndonos al objeto 02:16:07

que ha chocado con nosotros 02:16:09

o que ha atravesado nuestra 02:16:11

nuestro trigger, vale, si fuera un collider 02:16:13

on collision, vale 02:16:15

vais a ver que 02:16:17

es otro tipo, porque 02:16:19

permiten distintas opciones, por ejemplo 02:16:21

en collision se puede detectar 02:16:23

el punto exacto donde se ha colisionado 02:16:25

y en el on trigger, como solo importa que 02:16:27

atraviese el área, pues no 02:16:29

tiene tantas opciones, por eso son de distinto tipo 02:16:31

pero, el nombre que se le dé 02:16:33

a esta variable, luego dentro se puede 02:16:35

usar para referirse al objeto que 02:16:37

o ha colisionado con nosotros, en el caso del 02:16:39

on collision, o que nos ha atravesado 02:16:41

en el caso del on trigger, vale 02:16:43

entonces, lo que 02:16:45

luego podremos hacer, y esto 02:16:47

ya igual es demasiada tela 02:16:49

para hoy, es que si en algún 02:16:51

momento decimos, oye ojo 02:16:53

si, un condicional, si 02:16:55

el otro game object 02:16:57

tiene un nombre que es igual a bola 02:16:59

entonces si se ejecuta esto 02:17:01

si choca cualquier objeto y no se 02:17:03

cumple la condición de que se llame bola, esto 02:17:05

no se ejecuta, vale, y con esto 02:17:07

que es una de las dudas que 02:17:09

planteó Javier el otro día en el foro 02:17:11

que era, es que pongo el collider 02:17:13

el trigger, vamos 02:17:15

y se ejecuta todo el rato, claro, porque si este 02:17:17

me devuelvo a la escena 02:17:19

que teníamos 02:17:21

del nivel 1 02:17:23

lo guardo, vale, si este 02:17:25

collider al declararlo 02:17:27

lo voy a poner en wireframe para que se vea 02:17:29

este goal que tenemos aquí 02:17:31

esta caja, la ponemos tocando 02:17:33

la 02:17:35

la, como se llama 02:17:37

la malla, el collider 02:17:39

el mesh collider que tiene 02:17:41

la plataforma 02:17:43

claro, no está discriminando con que, entonces 02:17:45

según arranco 02:17:47

ya debería estar, a ver 02:17:49

lo que pasa es que no tendré algo puesto, bueno 02:17:51

claro, lo que pasa es que dentro de goal 02:17:53

fijaos en ese script que tengo 02:17:55

estoy discriminando que lo único 02:17:57

que puede atravesar y desencadenar que cambie 02:17:59

de escena es que se llame bola 02:18:01

pero si yo esto 02:18:03

lo dejara así 02:18:05

vale, y guardo 02:18:07

vais a ver que ahora si que como no 02:18:09

discrimina en cuanto arranco el juego cambia de nivel 02:18:11

si, me seguís 02:18:13

vale y voy a 02:18:15

volver a poner lo que había que 02:18:17

si no se me olvida 02:18:19

si 02:18:21

vale, parece que si, vale entonces 02:18:23

he dado mucha vuelta porque va a ser muy útil 02:18:25

a como los métodos, a que es 02:18:27

esto de los paréntesis y porque todos los 02:18:29

métodos tienen paréntesis aunque estén vacíos 02:18:31

vale, porque sirve para eso, para 02:18:33

pasar información que en cada caso 02:18:35

ejecutará el método de una forma 02:18:37

u otra, vale, fijaos que 02:18:39

como es void el onTrigger 02:18:41

no necesita el return, vale 02:18:43

que eso es un detalle muy importante porque 02:18:45

si no los métodos que tienen 02:18:47

que no tengan void sin return no 02:18:49

funcionan, vale, que esto 02:18:51

siempre nos da fallo a veces al declararlo y no 02:18:53

sabemos luego que es, vale, entonces 02:18:55

a ver, perdonad 02:18:57

que aquí había movido para no estar 02:18:59

yo luego distraído, esto está aquí 02:19:01

vale, entonces 02:19:03

ya por ir 02:19:05

acabando por ahí porque si no 02:19:07

se hace muy largo, demasiado largo 02:19:09

lo que estamos haciendo es, si 02:19:11

y esto se que de primeras 02:19:13

es nomenclatura complicada pero 02:19:15

estamos diciendo si al poner otro 02:19:17

other, si ponemos un punto podemos 02:19:19

decir, si el GameObject 02:19:21

guardado en other, vale 02:19:23

tiene este nombre, aquí ya podremos 02:19:25

decir que busque el nombre 02:19:27

vale, esto va a funcionar si hay un 02:19:29

GameObject que se llama bola, si aquí 02:19:31

pusiera bolas ya no funcionaría 02:19:33

este if, vale, se tiene que llamar 02:19:35

exactamente, vale, hay que tener mucho cuidado 02:19:37

con como nombramos las cosas 02:19:39

hay formas de discriminar luego con 02:19:41

etiquetas, esto se ve 02:19:43

más adelante, vale, o con capas 02:19:45

esto es más adelante, pero hay como distintas 02:19:47

formas de discriminar 02:19:49

que es, que objeto es el que toca 02:19:51

no solo por el nombre, vale, que a veces 02:19:53

nos puede interesar que esto se llame bolardo 02:19:55

y que por cambiar el nombre no deje 02:19:57

de ejecutar, pues se le puede poner una etiqueta y que 02:19:59

detecte en vez del nombre, vale, vais a ver 02:20:01

que también se puede poner etiqueta y no da fallo 02:20:03

ahora sería que la etiqueta que hay aquí 02:20:05

fuera de tipo bola, pero bueno 02:20:07

eso es más avanzado, vale 02:20:09

y aquí, por explicar 02:20:11

ya lo último esta 02:20:13

SteamManager, aquí lo que 02:20:15

se hace es, se declara una variable que 02:20:17

se llama ahí, un número, vale 02:20:19

y hay distintos métodos 02:20:21

vale, como este que 02:20:23

ActiveSteam, que pertenece 02:20:25

a la clase SteamManager 02:20:27

la SteamManager 02:20:29

existe cuando la incorporamos a través 02:20:31

de este, de esta librería, vale 02:20:33

que hemos puesto, siempre que vayamos a gestionar 02:20:35

algo relacionado con la gestión de escenas 02:20:37

ponemos SteamManager 02:20:39

vale, pues por ejemplo aquí 02:20:41

SteamManager, que hay alguna 02:20:43

funcionalidad más que ya vienen por defecto 02:20:45

vale, pero SteamManager al meter 02:20:47

con el punto tiene bastantes 02:20:49

utilidades, bastantes métodos pre-creados 02:20:51

para cargar una escena concreta 02:20:53

para conseguir 02:20:55

la escena en la que estamos 02:20:57

vale, esto ahora mismo 02:20:59

lo que, por lo que nos sirve para cualquier 02:21:01

escena es porque tenemos un método 02:21:03

que dice, oye, coge 02:21:05

la escena en la que estamos ahora mismo, vale 02:21:07

y me guardas el número de índice 02:21:09

vale 02:21:11

el número de índice, cuando ya 02:21:13

los que hayáis empezado la tarea, es 02:21:15

el número que hay en los BuildSettings, cuando vamos a 02:21:17

estando aquí los niveles, aquí se van 02:21:19

apilando números en orden 02:21:21

que nosotros luego podemos ir cambiando el orden 02:21:23

de la escena que tienen que referirse 02:21:25

a cada índice, y por ejemplo 02:21:27

el nivel 1 es el índice 0 02:21:29

el nivel 2 es el índice 1, vale 02:21:31

que el nombre nos confunda, el índice es el 02:21:33

que importa aquí, entonces 02:21:35

aquí lo que hacemos es 02:21:37

guárdame en esta variable i un número que es 02:21:39

el número de índice de la escena 02:21:41

en la que nos encontramos ahora mismo 02:21:43

que al ser el nivel 1 en este caso 02:21:45

sería 0, vale 02:21:47

entonces, para que lo entendamos bien 02:21:49

esta línea que tenemos aquí 02:21:51

i pasa a valer 0 02:21:53

si por ejemplo este script se ejecutara 02:21:55

mientras estamos en el nivel 3 02:21:57

el índice que se guardaría sería 02:21:59

2, vale 02:22:01

porque luego lo que hacemos con 02:22:03

el cargar escena es cargar 02:22:05

el número de escena que nos interese 02:22:07

que en este caso, si las tenemos bien en orden 02:22:09

consecutivas, vale 02:22:11

si queremos reiniciar, lo que tenemos que hacer 02:22:13

es decirle, oye, cárgame la escena 02:22:15

en la que nos encontramos, y cada vez 02:22:17

esto se podría poner, por ejemplo, en el precipicio 02:22:19

cada vez que 02:22:21

tocamos ese collider 02:22:25

ese trigger 02:22:27

aquí estaríamos cargando la misma escena 02:22:29

estaríamos reiniciando, si estamos en la 1 02:22:31

cargaría la escena 1 de nuevo 02:22:33

si estamos en la 2, la 2, pero si 02:22:35

tenemos bien organizado y queremos pasar de un nivel a otro 02:22:37

lo que haríamos es, oye 02:22:39

cuando toque la meta 02:22:41

lo que quiero es que 02:22:43

sea donde nos encontramos 02:22:45

más 1, es decir, si estamos en el nivel 02:22:47

de índice 0 02:22:49

pasaría a la 1, sino 02:22:51

de la 1 a la 2, de la 2 a la 3, vale 02:22:53

y con este mismo script, siempre 02:22:55

que tuviéramos un objeto en la escena 02:22:57

con un trigger 02:22:59

que detectara que le toca una bola 02:23:01

lo que haría sería pasar al nivel 02:23:03

al siguiente nivel 02:23:05

vale, entonces 02:23:07

con este script se podría poner 02:23:09

a todas las metas de un juego de millones de 02:23:11

pantallas que siempre pasaría al siguiente 02:23:13

nivel de los que tenemos aquí 02:23:15

en los build settings 02:23:17

vale 02:23:19

con esto más o menos explico el nivel 1 02:23:21

el próximo día 02:23:23

en un par de semanas, lo que pasa es que 02:23:25

viene el día 22 y 23 son festivos 02:23:27

a nivel lectivo 02:23:29

dentro de dos semanas no sé si da tiempo 02:23:31

entonces no sé si la semana que viene organizar 02:23:33

otra tutoría o ya dentro de tres semanas 02:23:35

un poco 02:23:37

según como vayáis avanzando 02:23:39

porque todo esto es muy interesante que yo lo explique 02:23:41

cuando ya habéis intentado hacer la tarea 02:23:43

y habéis leído el tema, porque si no 02:23:45

os estoy hablando, os estoy hablando, os estoy hablando 02:23:47

de nada, si más o menos habéis seguido 02:23:49

el tema y ya lo habéis medio intentado aunque no salga 02:23:51

nada, ya pues 02:23:53

me imagino que es bastante más fácil que se os vayan 02:23:55

quedando los conocimientos 02:23:57

porque sé que esto es complicado, pero bueno 02:23:59

aquí hay cosas ya del tema 1, del tema 0 02:24:01

que se van entremezclando 02:24:03

este 02:24:07

a ver, cuando había que entregar esta 02:24:09

esta, vale, a ver 02:24:11

un segundín 02:24:13

espera que lo miro 02:24:15

no sé si a mediados de mes 02:24:17

yo creo que le quedaba todavía 02:24:19

un par de semanas larguitas 02:24:21

a ver 02:24:23

el tema 3 02:24:25

para el domingo, pues no 02:24:27

lleva razón que es para este 02:24:29

día 02:24:31

vale, vamos a hacer una cosa 02:24:33

intentad entregarlo 02:24:35

si podéis, para esta fecha 02:24:37

en cualquier caso 02:24:39

lo que voy a hacer es abrir, si lo tenéis para esa fecha 02:24:41

mejor, voy a intentar abrir 02:24:43

la entrega para que sea hasta el 25 02:24:45

lo de siempre, a mi me da 02:24:47

miedo atrasar las entregas 02:24:49

no por otra cosa que, pues a mi no me importa 02:24:51

corregirlo en un par de semanas más tarde 02:24:53

y ya está, sino para forzaros a que ya 02:24:55

os pongáis con el siguiente tema, vale, para meteros 02:24:57

un poco de prisa, porque si no llegan 02:24:59

los dos últimos temas y seguimos con 02:25:01

las entregas anteriores, vale 02:25:03

entiendo que hay cosas que aquí estoy 02:25:05

desgranando más para que 02:25:07

las entendáis, pero realmente 02:25:09

está pensado para que la mayoría de cosas 02:25:11

las podáis hacer viendo los fragmentos de código que 02:25:13

hay y la explicación que hay en el propio enunciado 02:25:15

pero entiendo que es complicado, eh, no 02:25:17

entiendo que juegue 02:25:19

pero si vais con constancia ya más o menos lo tendríais 02:25:21

bastante hecho, aunque no entendierais 02:25:23

muchas de las cosas a lo mejor que estáis entendiendo hoy 02:25:25

entonces 02:25:27

una pregunta solamente 02:25:29

si, si, claro 02:25:31

mira, una pregunta, solamente 02:25:33

en el tema de las plataformas 02:25:35

entiendo que para 02:25:37

hacer el atorque 02:25:39

no hay que hacer un 02:25:41

atfor, sino que tiene que ser 02:25:43

tanto en el H como en el V 02:25:45

atorque, entiendo 02:25:47

en el caso de la bola da un poco 02:25:49

igual, porque una bola cuando le aplicas una fuerza 02:25:51

como es redonda, es como un 02:25:53

torque en realidad, vale, entonces 02:25:55

en la bola se puede hacer con atforce y con 02:25:57

atorque, que es lo que hemos visto antes 02:25:59

sí que es verdad que luego voy al nivel 02:26:01

2, un segundín 02:26:03

en el nivel 2 y de hecho así os 02:26:05

comento un par de cosas, queremos no que 02:26:07

vaya hacia delante o hacia atrás o rote, queremos 02:26:09

es decir, perdonad 02:26:11

que rote sí, lo que queremos es añadir 02:26:13

un torque, vale 02:26:15

tenemos aquí, os abro el código 02:26:17

para que veáis 02:26:19

que la rotación de esa plataforma 02:26:21

es de una forma 02:26:23

muy muy parecida a la que os he enseñado 02:26:25

antes con la bola, son dos atorques 02:26:27

uno para cada eje, vale 02:26:29

el horizontal y el vertical, que además se pueden 02:26:31

sumar, si estamos tocando estos dos inputs 02:26:33

a la vez, pues irá en diagonal 02:26:35

entonces, fijaos que es un poco lo 02:26:37

mismo, aquí el mayor problema 02:26:39

que puede suceder, lo explico rápido para 02:26:41

casi 02:26:43

decir, el único escollo que quedaría 02:26:45

vale, aparte de coger soltura 02:26:47

que es, y esto está 02:26:49

explicado en uno de los silos del foro, vale 02:26:51

voy a ir muy rápido, pero que es 02:26:53

que cuando metáis la geometría de la 02:26:55

plataforma con su mesh 02:26:57

collider y su malla 02:26:59

vale, vais a tener 02:27:01

lo vais a tener 02:27:03

que dejar para que coja el agujero sin 02:27:05

marcar el convex, pero si 02:27:07

marcáis el convex, os va a dar un fallo 02:27:09

a la hora de aplicar 02:27:11

fuerzas 02:27:13

al rigid body 02:27:15

vale, porque os va a pedir que sea kinemático 02:27:17

por supuesto también, cuando 02:27:19

como aquí vais a añadir 02:27:21

add torques a la propia plataforma 02:27:23

recordad que aquí 02:27:25

los add torques y los add forces se aplican 02:27:27

al componente rigid body 02:27:29

y cuando ponemos un rigid body, por defecto tiene 02:27:31

la gravedad marcada, pero aquí no nos 02:27:33

interesa que la plataforma tenga gravedad, queremos 02:27:35

que esté fija en un sitio, vale 02:27:37

por tanto, desmarcad el usar gravedad 02:27:39

eso lo primero, pero eso 02:27:41

como, mientras lo 02:27:43

vais haciendo, vais a ver que os obliga a ello 02:27:45

cuando metáis este mesh collider para que detecte 02:27:47

este agujero, no podéis marcar el convex 02:27:49

porque si no, os va a dar un fallo a la hora 02:27:51

de dar una fuerza, vale 02:27:53

entonces, hay que desgranar por un lado 02:27:55

el objeto 02:27:57

que sirve de collider, vale 02:27:59

que sirve de 02:28:01

punto de 02:28:03

de contacto 02:28:05

para que la bola sepa donde es, y luego 02:28:07

un elemento padre 02:28:09

que es el que realmente va a 02:28:11

mover la plataforma con su rigid body 02:28:13

vale, y que va a heredar 02:28:15

la posición a la geometría 02:28:17

y al collider, esto si lo habéis intentado 02:28:19

hacer, ya os habrán surgido algunos problemas 02:28:21

porque si yo intentara 02:28:23

hacer el movimiento directamente en este 02:28:25

rigid body, que sería lo lógico, vale 02:28:27

os va a obligar a poner 02:28:29

que es convex, vale 02:28:31

o que este is kinematic 02:28:33

no puede estar marcado, porque si no sale un error 02:28:35

de este tipo, a ver 02:28:37

a ver 02:28:39

mierda, perdona 02:28:41

tutu 02:28:43

si 02:28:45

bueno 02:28:47

lo que voy a hacer es quitar esto de aquí 02:28:49

un segundo, y este 02:28:51

lo quito, vale 02:28:53

si por defecto hacéis lo que intentáis hacer 02:28:55

e intentáis añadir una fuerza a este 02:28:57

objeto, mirad 02:28:59

que sale este error, vale 02:29:01

non convex mesh collider con no kinematic 02:29:03

vale, para que detecte bien 02:29:05

esta geometría, vale 02:29:07

a ver, tenéis que ponerlo 02:29:09

en no convex, vale 02:29:11

para que salga completamente 02:29:13

y luego eso os va a 02:29:15

impedir que esto 02:29:17

hay que ponerlo en kinematico, para decir 02:29:19

tiene que ser kinematico para que funcione y para que detecte bien 02:29:21

la malla, tendrá que ser de este modo 02:29:23

vais a ver que aunque probéis distintas combinaciones 02:29:25

no va a funcionar, y cuando es 02:29:27

kinematico, no va 02:29:29

a realizar de manera correcta las fuerzas 02:29:31

porque cuando un objeto, esto también 02:29:33

necesita una explicación igual más amplia 02:29:35

pero un objeto se puede mover 02:29:37

por físicas, como estamos haciendo ahora 02:29:39

o como hemos hecho 02:29:41

en los temas anteriores, en la unidad 2 02:29:43

por kinematicas, que es usar 02:29:45

el movimiento 02:29:47

por coordenadas del transform, vale 02:29:49

aquí ahora mismo, si decimos que este objeto 02:29:51

es kinematico, no va 02:29:53

a recibir bien las fuerzas, no lo va a aplicar bien 02:29:55

entonces la solución cuando veáis 02:29:57

que no sabéis como seguir, es porque 02:29:59

lo que hay que hacer es derivar 02:30:01

todo lo que es el movimiento mediante 02:30:03

mediante 02:30:05

fuerzas, en otro rigidbody 02:30:07

que si va asociado al script 02:30:09

y que va a ser el padre que va a hacer 02:30:11

girar, vale, como heredan los movimientos 02:30:13

y las rotaciones, esto va a girar 02:30:15

y aunque no haya nada visible 02:30:17

va a servir para que gire la plataforma 02:30:19

es una especie de requiebro 02:30:21

que a veces hay que hacer 02:30:23

para que funcionen las cosas 02:30:25

esto también a nivel de código muchas veces 02:30:27

no se os permite hacer algo 02:30:29

porque no lo permite hacer 02:30:31

y hay que crear una variable que luego se mete de otra forma 02:30:33

vale, hay que buscar otros tipos de 02:30:35

métodos, vale, entonces 02:30:37

ya os digo 02:30:39

en el hilo está resuelto con capturas 02:30:41

un poco de como hay que irlo poniendo para que esto se pueda mover 02:30:43

correctamente, y si, en el terreno 02:30:45

el padre, vale, habrá que meter 02:30:47

los dos axis 02:30:49

vale, que mueven y con addtorques 02:30:51

haremos, como no hay gravedad 02:30:53

vale, ojo, no pongáis la gravedad que si no 02:30:55

se caerá, vale 02:30:57

hacemos la rotación 02:30:59

vale, eso, si ponemos gravedad 02:31:01

vale 02:31:03

lo que va a pasar 02:31:05

es que la plataforma 02:31:07

se está cayendo en todo momento y creo que 02:31:09

no se está viendo, bueno 02:31:11

a ver, un segundo 02:31:13

bueno, lo que pasa es que 02:31:15

como es kinemático se queda quieto 02:31:17

vale, no pasa 02:31:19

nada, porque otro de los efectos derivados 02:31:21

de que nos está obligando 02:31:23

a decir que es kinemático es 02:31:25

que al hacerlo kinemático, es decir, que se mueve por 02:31:27

las coordenadas, se convierte en un objeto 02:31:29

estático, no tiene 02:31:31

ese es el problema, que cuando 02:31:33

hacemos un objeto kinemático 02:31:35

un rellipo de kinemático no 02:31:37

se le aplica la fuerza de la gravedad de manera 02:31:39

normal, entonces 02:31:41

la gravedad por ejemplo no funciona, las físicas tampoco 02:31:43

vale, vale 02:31:45

y bueno, y luego otra cosa importante 02:31:47

para que el 02:31:49

la meta esté 02:31:51

todo el rato dentro del agujero, hacerlo también hijo 02:31:53

de lo que rota, y así siempre estará 02:31:55

dentro del agujero, porque si no 02:31:57

cuando rotemos, vale, lo que va a pasar 02:31:59

es lo que vamos a ver aquí, que es 02:32:01

que la meta se queda en su sitio 02:32:03

y entonces la bola ya no llega ahí 02:32:05

vale, emplead los 02:32:07

emparentamientos, las jerarquías 02:32:09

bueno, perdonad que he hablado muchísimo 02:32:11

que tal hasta aquí, dudas 02:32:13

algo que se os quede hasta este momento, que queráis 02:32:15

que veamos 02:32:17

intentaremos hacerlo para el domingo, me queda 02:32:19

solamente la última, la plataforma 02:32:21

última y ya está, intentaré hacerlo 02:32:23

complicado es, madre mía 02:32:25

esto es tremendo, vale 02:32:27

por un lado, me alegra mucho que casi lo tengas 02:32:29

hecho, porque significa que te has pegado mucho con el software 02:32:31

y has ido aprendiendo cosas, estoy 02:32:33

convencido de que tú la clase de hoy la has seguido mucho mejor 02:32:35

que un estudiante que 02:32:37

se haya leído solo medio tema 3 02:32:39

y no se haya puesto, estoy convencidísimo 02:32:41

y eso es lo que me interesa 02:32:43

eh, ya os digo 02:32:45

si no llegáis en plazo, bueno 02:32:47

lo primero es que las actividades 02:32:49

suben muy poca nota y 02:32:51

aunque lo entreguéis fuera de plazo 02:32:53

eh, igual no suma 02:32:55

para la nota, pero también es 02:32:57

la podéis entregar, al menos en un plazo 02:32:59

en un plazo razonable después 02:33:01

pero, lo importante 02:33:03

aquí es que os peguéis 02:33:05

sí que, si vais entendiendo pues lo que hemos visto 02:33:07

hoy, cómo se declara un método y cómo se 02:33:09

pueden declarar varias sobrecargas 02:33:11

de un mismo método y por qué están estos paréntesis 02:33:13

y para qué sirven 02:33:15

pues hoy hemos avanzado un montón 02:33:17

vale, si entendéis lo de hoy 02:33:19

entonces, bueno, que es un poco el enfoque 02:33:21

que quiero darle 02:33:23

bueno, pues nada, muchas gracias 02:33:25

y hasta la próxima 02:33:27

Tutoría 6 - DEIM - UT3 - Curso 23·24 - 8 Febrero - Contenido educativo

Del mismo autor…

Vídeo resumen "La evolución de los seres vivos" 4º ESO, Biología

Vídeo resumen "Alteraciones genéticas" 4º ESO, Biología

Vídeo resumen "La célula" 4º ESO, Biología

Miniconferencia Cloe

Miniconferencia de Enzo

MINICONFERENCIA JOSE

Vídeo resumen "El origen de la vida", 4º ESO, Biología